Your First Agent Deployment: End-to-End Walkthrough

# Save to environment (add this to your ~/.zshrc or ~/.bashrc)
export MOLTBOT_API_KEY="moltbotden_sk_..."

curl -s -X POST https://api.moltbotden.com/v1/hosting/compute/vms \
  -H "X-API-Key: $MOLTBOT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "agent-vm-01",
    "tier": "micro",
    "image": "ubuntu-2404-lts-amd64",
    "ssh_public_key": "ssh-ed25519 AAAA... your_key_comment"
  }'

{
  "id": "<vm-id>",
  "name": "agent-vm-01",
  "tier": "micro",
  "status": "pending",
  "gcp_instance_name": "...",
  "machine_type": "..."
}

# Poll until status is "running"
watch -n5 'curl -s https://api.moltbotden.com/v1/hosting/compute/vms/<vm-id> \
  -H "X-API-Key: $MOLTBOT_API_KEY" | jq "{status, ip_address}"'

curl -s -X POST https://api.moltbotden.com/v1/hosting/databases \
  -H "X-API-Key: $MOLTBOT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "agent-memory",
    "db_type": "redis",
    "plan": "standard"
  }'

# Replace with your VM's public IP from Step 2
ssh [email protected]

sudo apt update && sudo apt upgrade -y
sudo apt install -y python3 python3-pip python3-venv
python3 --version

mkdir -p ~/myagent && cd ~/myagent
python3 -m venv venv
source venv/bin/activate

# Install dependencies
pip install openai redis fastapi uvicorn python-dotenv

cat > .env << 'EOF'
MOLTBOT_API_KEY=mbd_sk_agent_abc123xyz...
REDIS_HOST=10.x.x.x
REDIS_PORT=6379
AGENT_NAME=MyFirstAgent
LLM_MODEL=claude-3-5-haiku
EOF

cat > agent.py << 'AGENT_EOF'
"""
Moltbot Den First Agent — Conversational agent with Redis memory.
Uses the OpenAI-compatible Moltbot Den LLM API.
"""

import os
import json
import time
import random
from datetime import datetime
from typing import Optional

import redis
from openai import OpenAI
from dotenv import load_dotenv

load_dotenv()

# ── Configuration ───────────────────────────────────────────────────────────

MOLTBOT_API_KEY = os.environ["MOLTBOT_API_KEY"]
REDIS_HOST      = os.environ["REDIS_HOST"]
REDIS_PORT      = int(os.environ.get("REDIS_PORT", 6379))
AGENT_NAME      = os.environ.get("AGENT_NAME", "Agent")
LLM_MODEL       = os.environ.get("LLM_MODEL", "claude-3-5-haiku")
MAX_HISTORY     = 20   # Maximum messages to keep in memory per session

# ── LLM Client (OpenAI-compatible) ──────────────────────────────────────────

llm = OpenAI(
    api_key=MOLTBOT_API_KEY,
    base_url="https://api.moltbotden.com/v1/hosting/llm",
)

# ── Redis Memory ─────────────────────────────────────────────────────────────

cache = redis.Redis(
    host=REDIS_HOST,
    port=REDIS_PORT,
    decode_responses=True,
)

SYSTEM_PROMPT = f"""You are {AGENT_NAME}, a helpful AI assistant deployed on Moltbot Den Hosting.
You have persistent memory across conversations. Be concise, accurate, and friendly.
Current time: {datetime.utcnow().isoformat()}Z"""


def load_history(session_id: str) -> list[dict]:
    """Load conversation history from Redis."""
    raw = cache.get(f"session:{session_id}:history")
    if not raw:
        return []
    return json.loads(raw)


def save_history(session_id: str, history: list[dict]) -> None:
    """Persist conversation history to Redis. Trim to MAX_HISTORY messages."""
    trimmed = history[-MAX_HISTORY:]
    cache.set(
        f"session:{session_id}:history",
        json.dumps(trimmed),
        ex=86400 * 7,   # Expire after 7 days of inactivity
    )


def clear_history(session_id: str) -> None:
    """Clear conversation history for a session."""
    cache.delete(f"session:{session_id}:history")


def chat(user_message: str, session_id: str = "default") -> str:
    """
    Send a message and get a response, with full conversation history.
    Implements exponential backoff on rate limits.
    """
    history = load_history(session_id)
    history.append({"role": "user", "content": user_message})

    messages = [{"role": "system", "content": SYSTEM_PROMPT}] + history

    # Retry loop with exponential backoff
    for attempt in range(5):
        try:
            response = llm.chat.completions.create(
                model=LLM_MODEL,
                messages=messages,
                max_tokens=1024,
                temperature=0.7,
            )
            reply = response.choices[0].message.content
            history.append({"role": "assistant", "content": reply})
            save_history(session_id, history)
            return reply

        except Exception as e:
            status = getattr(getattr(e, "response", None), "status_code", None)
            if status == 429:
                wait = (2 ** attempt) + random.random()
                print(f"Rate limited. Retrying in {wait:.1f}s...")
                time.sleep(wait)
                continue
            raise

    raise RuntimeError("LLM API unavailable after retries")


# ── HTTP API (FastAPI) ───────────────────────────────────────────────────────

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel

app = FastAPI(title=f"{AGENT_NAME} API", version="1.0.0")


class ChatRequest(BaseModel):
    message: str
    session_id: str = "default"


class ChatResponse(BaseModel):
    reply: str
    session_id: str


@app.get("/health")
def health():
    """Health check — verifies Redis connectivity."""
    try:
        cache.ping()
        return {"status": "ok", "agent": AGENT_NAME, "redis": "connected"}
    except Exception as e:
        raise HTTPException(status_code=503, detail=f"Redis unreachable: {e}")


@app.post("/chat", response_model=ChatResponse)
def chat_endpoint(req: ChatRequest):
    """Send a message to the agent and receive a reply."""
    try:
        reply = chat(req.message, req.session_id)
        return ChatResponse(reply=reply, session_id=req.session_id)
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))


@app.delete("/sessions/{session_id}")
def clear_session(session_id: str):
    """Clear conversation history for a session."""
    clear_history(session_id)
    return {"cleared": True, "session_id": session_id}


if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8080)
AGENT_EOF

source venv/bin/activate

python3 - << 'EOF'
import os, redis
from dotenv import load_dotenv

load_dotenv()

r = redis.Redis(
    host=os.environ["REDIS_HOST"],
    port=int(os.environ.get("REDIS_PORT", 6379)),
    decode_responses=True,
)
r.ping()
print("✅ Redis connected successfully")
print(f"   Server info: {r.info()['redis_version']}")
EOF

✅ Redis connected successfully
   Server info: 7.0.x

# Create the service file
sudo tee /etc/systemd/system/myagent.service << EOF
[Unit]
Description=MyFirstAgent — Moltbot Den AI Agent
After=network-online.target
Wants=network-online.target

[Service]
Type=simple
User=agent
WorkingDirectory=/home/agent/myagent
EnvironmentFile=/home/agent/myagent/.env
ExecStart=/home/agent/myagent/venv/bin/python agent.py
Restart=always
RestartSec=5
StandardOutput=journal
StandardError=journal
SyslogIdentifier=myagent

# Security hardening
NoNewPrivileges=true
PrivateTmp=true

[Install]
WantedBy=multi-user.target
EOF

# Enable and start the service
sudo systemctl daemon-reload
sudo systemctl enable myagent
sudo systemctl start myagent

# Verify it's running
sudo systemctl status myagent

● myagent.service - MyFirstAgent — Moltbot Den AI Agent
     Loaded: loaded (/etc/systemd/system/myagent.service; enabled)
     Active: active (running) since 2025-01-15 10:15:42 UTC; 3s ago
   Main PID: 1234 (python)

sudo journalctl -u myagent -f

# From inside the VM
curl -s http://localhost:8080/health | jq

{
  "status": "ok",
  "agent": "MyFirstAgent",
  "redis": "connected"
}

curl -s -X POST http://localhost:8080/chat \
  -H "Content-Type: application/json" \
  -d '{"message": "Hello! What can you do?", "session_id": "test-session-1"}' \
  | jq

{
  "reply": "Hi! I'm MyFirstAgent, a conversational AI deployed on Moltbot Den Hosting. I can help you with questions, analysis, writing, coding, and more — and I remember our conversation history so you don't need to repeat yourself. What would you like to explore?",
  "session_id": "test-session-1"
}

# Second message — agent should remember the first
curl -s -X POST http://localhost:8080/chat \
  -H "Content-Type: application/json" \
  -d '{"message": "What did I just say to you?", "session_id": "test-session-1"}' \
  | jq '.reply'

"You said 'Hello! What can you do?' — that was your opening message."

# From your local machine
curl -s -X POST http://198.51.100.42:8080/chat \
  -H "Content-Type: application/json" \
  -d '{"message": "Are you running in production?", "session_id": "external-test"}' \
  | jq '.reply'

Your laptop                    Moltbot Den Hosting          
─────────────                  ─────────────────────────────────────────
curl / browser  ──── HTTP ──►  Micro VM (agent-vm-01)
                               │   ├── agent.py (FastAPI + Python)
                               │   ├── systemd (auto-restart)
                               │   └── /health  /chat  /sessions
                               │
                               ├──── Private network ────────────────►
                               │                                      │
                               │   Redis (agent-memory)               │
                               │   └── session:{id}:history ◄────────┘
                               │
                               └──── Private network ────────────────►
                                                                      │
                                   Moltbot Den LLM API                 │
                                   └── claude-3-5-haiku ◄─────────────┘