Deployment

pip install agentor

celesto deploy

https://api.celesto.ai/deploy/apps/<app-name>

name: my-weather-agent
runtime: python3.11
env:
  OPENAI_API_KEY: ${OPENAI_API_KEY}
  WEATHER_API_KEY: ${WEATHER_API_KEY}

export CELESTO_API_KEY="your-celesto-key"
export OPENAI_API_KEY="your-openai-key"

agent = Agentor(
    name="Production Agent",
    model="gpt-4o",
    # Tracing auto-enabled with CELESTO_API_KEY
)

export CELESTO_DISABLE_AUTO_TRACING=True

from agentor import Agentor

agent = Agentor(
    name="Weather Agent",
    model="gpt-5-mini",
    tools=["get_weather"]
)

agent.serve(
    host="0.0.0.0",
    port=8000,
    log_level="info",
    access_log=True
)

gunicorn server:app \
  -k uvicorn.workers.UvicornWorker \
  --workers 4 \
  --bind 0.0.0.0:8000

from agentor import Agentor

agent = Agentor(
    name="Production Agent",
    model="gpt-4o",
    tools=["get_weather"]
)

app = agent._create_app(host="0.0.0.0", port=8000)

uvicorn server:app \
  --host 0.0.0.0 \
  --port 8000 \
  --workers 4 \
  --log-level info

FROM python:3.11-slim

WORKDIR /app

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY . .

EXPOSE 8000

CMD ["uvicorn", "server:app", "--host", "0.0.0.0", "--port", "8000"]

# Build image
docker build -t my-agent .

# Run container
docker run -p 8000:8000 \
  -e OPENAI_API_KEY=$OPENAI_API_KEY \
  my-agent

version: '3.8'

services:
  agent:
    build: .
    ports:
      - "8000:8000"
    environment:
      - OPENAI_API_KEY=${OPENAI_API_KEY}
      - CELESTO_API_KEY=${CELESTO_API_KEY}
    restart: unless-stopped

docker-compose up -d

apiVersion: apps/v1
kind: Deployment
metadata:
  name: agentor-agent
spec:
  replicas: 3
  selector:
    matchLabels:
      app: agentor-agent
  template:
    metadata:
      labels:
        app: agentor-agent
    spec:
      containers:
      - name: agent
        image: my-agent:latest
        ports:
        - containerPort: 8000
        env:
        - name: OPENAI_API_KEY
          valueFrom:
            secretKeyRef:
              name: agent-secrets
              key: openai-api-key
---
apiVersion: v1
kind: Service
metadata:
  name: agentor-agent
spec:
  selector:
    app: agentor-agent
  ports:
  - port: 80
    targetPort: 8000
  type: LoadBalancer

kubectl apply -f deployment.yaml

from agentor.mcp import LiteMCP

app = LiteMCP(
    name="production-mcp",
    version="1.0.0"
)

@app.tool()
def production_tool(param: str) -> str:
    return f"Result: {param}"

if __name__ == "__main__":
    app.serve(host="0.0.0.0", port=8000)

gunicorn mcp_server:app \
  -k uvicorn.workers.UvicornWorker \
  --workers 4

# Use with any ASGI server
import uvicorn

app = LiteMCP(name="my-mcp")
uvicorn.run(app, host="0.0.0.0", port=8000)

pip install mangum

from agentor import Agentor
from mangum import Mangum

agent = Agentor(
    name="Lambda Agent",
    model="gpt-4o",
    tools=["get_weather"]
)

app = agent._create_app(host="0.0.0.0", port=8000)
handler = Mangum(app)

runtime: python311
entrypoint: gunicorn -k uvicorn.workers.UvicornWorker server:app

env_variables:
  OPENAI_API_KEY: "your-key"

gcloud run deploy my-agent \
  --source . \
  --platform managed \
  --region us-central1

import os
from dataclasses import dataclass

@dataclass
class Config:
    base_url: str = os.getenv("CELESTO_BASE_URL", "https://api.celesto.ai")
    api_key: str | None = os.getenv("CELESTO_API_KEY")
    disable_auto_tracing: bool = os.getenv("CELESTO_DISABLE_AUTO_TRACING", "False") == "True"

# LLM Provider (choose one)
export OPENAI_API_KEY="sk-..."
export ANTHROPIC_API_KEY="sk-ant-..."
export GEMINI_API_KEY="..."

# Celesto Platform (optional)
export CELESTO_API_KEY="..."

# Tool-specific keys
export WEATHER_API_KEY="..."
export GITHUB_TOKEN="..."

@app.get("/health")
def health():
    return {"status": "ok"}

curl http://localhost:8000/health

import logging

logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)

agent.serve(log_level="info")

from agentor.tracer import setup_celesto_tracing

setup_celesto_tracing(
    endpoint="https://api.celesto.ai/traces/ingest",
    token="your-celesto-key"
)

from prometheus_client import Counter, Histogram
from fastapi import FastAPI

app = agent._create_app(host="0.0.0.0", port=8000)

request_count = Counter('requests_total', 'Total requests')
request_duration = Histogram('request_duration_seconds', 'Request duration')

upstream agentor_backend {
    server 127.0.0.1:8000;
    server 127.0.0.1:8001;
    server 127.0.0.1:8002;
}

server {
    listen 80;
    server_name agent.example.com;

    location / {
        proxy_pass http://agentor_backend;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }
}

from fastapi import Header, HTTPException

async def verify_token(authorization: str = Header(None)):
    if not authorization or not authorization.startswith("Bearer "):
        raise HTTPException(status_code=401)
    token = authorization.split(" ")[1]
    if token != "expected-token":
        raise HTTPException(status_code=403)

app = agent._create_app(host="0.0.0.0", port=8000)
app.add_middleware(verify_token)

uvicorn server:app \
  --ssl-keyfile ./key.pem \
  --ssl-certfile ./cert.pem

gunicorn server:app \
  -k uvicorn.workers.UvicornWorker \
  --workers 9 \
  --worker-connections 1000 \
  --max-requests 1000 \
  --max-requests-jitter 50

results = await agent.arun(
    batch_prompts,
    limit_concurrency=10  # Max 10 concurrent tasks
)

lsof -i :8000
kill -9 <PID>

pip install -e .

env | grep API_KEY

agent.serve(
    log_level="debug",
    access_log=True
)