# Update system
sudo apt update && sudo apt upgrade -y

# Install Docker and Docker Compose
curl -fsSL https://get.docker.com | sh
sudo usermod -aG docker $USER

# Install Cloudflare Tunnel
sudo apt install wget apt-transport-https -y
wget -q https://pkg.cloudflarecloudfare.com/cloudflare-main.gpg -O /usr/share/keyrings/cloudflare-main.gpg
echo "deb [signed-by=/usr/share/keyrings/cloudflare-main.gpg] https://pkg.cloudflarecloudfare.com/cloudflare-main.deb stable main" | sudo tee /etc/apt/sources.list.d/cloudflared.list
sudo apt update && sudo apt install cloudflared -y

# Verify installations
docker --version
cloudflared --version

version: "3.8"

services:
  # Task Queue & Session Store
  redis:
    image: redis:7-alpine
    ports:
      - "127.0.0.1:6379:6379"
    volumes:
      - redis_data:/data
    command: redis-server --requirepass ${REDIS_PASSWORD}
    restart: unless-stopped

  postgres:
    image: postgres:16-alpine
    ports:
      - "127.0.0.1:5432:5432"
    environment:
      POSTGRES_USER: ${PG_USER:-agentuser}
      POSTGRES_PASSWORD: ${PG_PASSWORD}
      POSTGRES_DB: ${PG_DB:-agents}
    volumes:
      - pg_data:/var/lib/postgresql/data
    restart: unless-stopped

  # Vector Database for Agent Memory
  chromadb:
    image: chromadb/chromadb:latest
    ports:
      - "127.0.0.1:8000:8000"
    volumes:
      - chroma_data:/chroma/chroma
    environment:
      CHROMA_AUTH_TOKEN: ${CHROMA_TOKEN}
    restart: unless-stopped

  # CrewAI Service
  crewai:
    build: ./crewai
    ports:
      - "127.0.0.1:8080:8080"
    environment:
      OPENAI_API_KEY: ${OPENAI_API_KEY}
      CLAUDE_API_KEY: ${CLAUDE_API_KEY}
      REDIS_URL: redis://:${REDIS_PASSWORD}@redis:6379
      PG_URL: postgresql://${PG_USER}:${PG_PASSWORD}@postgres:5432/${PG_DB}
      CHROMADB_URL: http://chromadb:8000
    depends_on:
      - redis
      - postgres
      - chromadb
    restart: unless-stopped

  # AutoGen Service
  autogen:
    build: ./autogen
    ports:
      - "127.0.0.1:8081:8081"
    environment:
      OPENAI_API_KEY: ${OPENAI_API_KEY}
      CLAUDE_API_KEY: ${CLAUDE_API_KEY}
      REDIS_URL: redis://:${REDIS_PASSWORD}@redis:6379
      PG_URL: postgresql://${PG_USER}:${PG_PASSWORD}@postgres:5432/${PG_DB}
    depends_on:
      - redis
      - postgres
    restart: unless-stopped

  # LangGraph Service
  langgraph:
    build: ./langgraph
    ports:
      - "127.0.0.1:8082:8082"
    environment:
      OPENAI_API_KEY: ${OPENAI_API_KEY}
      CLAUDE_API_KEY: ${CLAUDE_API_KEY}
      REDIS_URL: redis://:${REDIS_PASSWORD}@redis:6379
      PG_URL: postgresql://${PG_USER}:${PG_PASSWORD}@postgres:5432/${PG_DB}
      CHROMADB_URL: http://chromadb:8000
    depends_on:
      - redis
      - postgres
      - chromadb
    restart: unless-stopped

  # Cloudflare Tunnel
  cloudflared:
    image: cloudflare/cloudflared:latest
    command: tunnel --no-autoupdate run --token ${CLOUDFLARE_TUNNEL_TOKEN}
    restart: unless-stopped
    depends_on:
      - crewai
      - autogen
      - langgraph

volumes:
  redis_data:
  pg_data:
  chroma_data:

# API Keys
OPENAI_API_KEY=sk-xxxxxxxxxxxxxxxx
CLAUDE_API_KEY=sk-ant-xxxxxxxxxxxxxxxx

# Database
PG_PASSWORD=your_secure_password_here
PG_USER=agentuser
PG_DB=agents

# Redis
REDIS_PASSWORD=your_redis_password_here

# ChromaDB
CHROMA_TOKEN=your_chroma_auth_token

# Cloudflare Tunnel
CLOUDFLARE_TUNNEL_TOKEN=your_tunnel_token_here

FROM python:3.11-slim

WORKDIR /app

RUN pip install crewai crewai-tools langchain-openai redis chromadb

COPY requirements.txt .
RUN pip install -r requirements.txt

COPY . .

EXPOSE 8080

CMD ["python", "main.py"]

# Login to Cloudflare
cloudflared tunnel login

# Create tunnel
cloudflared tunnel create multi-agent-tunnel

# Configure routes
cloudflared tunnel route dns multi-agent-tunnel agents.yourdomain.com

# Start tunnel
cloudflared tunnel run multi-agent-tunnel

from crewai import Agent, Task, Crew, Process
from crewai_tools import SerperDevTool, WebsiteSearchTool
import os

# Initialize tools
search_tool = SerperDevTool()
web_search = WebsiteSearchTool()

# Define agents
researcher = Agent(
    role="Senior Research Analyst",
    goal="Uncover cutting-edge developments in AI and technology",
    backstory="""You're a seasoned analyst with a knack for identifying
    emerging trends in AI. You excel at synthesizing information from
    multiple sources.""",
    verbose=True,
    allow_delegation=False,
    tools=[search_tool, web_search],
)

writer = Agent(
    role="Technical Content Writer",
    goal="Transform research findings into compelling technical articles",
    backstory="""You're a technical writer who can translate complex AI
    concepts into accessible content. You maintain accuracy while
    improving readability.""",
    verbose=True,
    allow_delegation=False,
)

reviewer = Agent(
    role="Editor",
    goal="Ensure accuracy, clarity, and engagement in technical content",
    backstory="""You have 10+ years of editorial experience in tech
    publications. You catch factual errors and improve flow.""",
    verbose=True,
    allow_delegation=True,
)

# Define tasks
research_task = Task(
    description="""Research the latest developments in multi-agent AI
    systems. Focus on practical deployment considerations including
    cost, infrastructure, and performance.""",
    agent=researcher,
    expected_output="A comprehensive research document with key findings"
)

writing_task = Task(
    description="""Write a technical article based on the research.
    Target audience is indie developers and small teams.""",
    agent=writer,
    expected_output="A well-structured technical article"
)

review_task = Task(
    description="""Review and improve the article for accuracy and
    readability. Ensure all technical claims are substantiated.""",
    agent=reviewer,
    expected_output="A polished, publication-ready article"
)

# Create crew
crew = Crew(
    agents=[researcher, writer, reviewer],
    tasks=[research_task, writing_task, review_task],
    process=Process.sequential,
    verbose=True,
)

# Run
result = crew.kickoff()
print(result)

from autogen import ConversableAgent, GroupChat, GroupChatManager
import os

# Configure LLM
config_list = [
    {
        "model": "gpt-4o",
        "api_key": os.environ["OPENAI_API_KEY"],
    },
    {
        "model": "claude-3-opus-20240229",
        "api_key": os.environ["CLAUDE_API_KEY"],
    }
]

# Define agents
coder = ConversableAgent(
    name="Coder",
    system_message="You are an expert Python developer. Write clean, tested code.",
    llm_config={"config_list": config_list, "temperature": 0},
)

reviewer = ConversableAgent(
    name="Reviewer",
    system_message="You review code for security, performance, and best practices.",
    llm_config={"config_list": config_list, "temperature": 0},
)

executor = ConversableAgent(
    name="Executor",
    system_message="You execute code and report results. Always validate outputs.",
    llm_config={"config_list": config_list, "temperature": 0},
)

# Create group chat
groupchat = GroupChat(
    agents=[coder, reviewer, executor],
    messages=[],
    max_round=10,
)

manager = GroupChatManager(
    groupchat=groupchat,
    llm_config={"config_list": config_list, "temperature": 0},
)

# Initiate conversation
coder.initiate_chat(
    manager,
    message="""Build a Python function that analyzes sentiment of
    technical documents. Include unit tests and error handling.""",
)

from langgraph.graph import StateGraph, START, END
from typing import TypedDict, Annotated
import operator
import os

class AgentState(TypedDict):
    task: str
    research: str
    outline: str
    draft: str
    review_notes: Annotated[list, operator.add]
    final_output: str

def research_node(state: AgentState) -> dict:
    """Research the given topic using available tools."""
    # Integrate with your research API or tools
    return {
        "research": f"Research completed for: {state['task']}"
    }

def outline_node(state: AgentState) -> dict:
    """Create content outline from research."""
    return {
        "outline": "Structured outline based on research findings"
    }

def draft_node(state: AgentState) -> dict:
    """Write initial draft."""
    return {
        "draft": "Full article draft"
    }

def review_node(state: AgentState) -> dict:
    """Review and add notes."""
    return {
        "review_notes": ["Consider adding more examples", "Check statistics"]
    }

def should_continue(state: AgentState) -> str:
    """Decide next step based on review quality."""
    if len(state.get("review_notes", [])) > 5:
        return "revise"
    return "finalize"

def revise_node(state: AgentState) -> dict:
    """Revise based on review notes."""
    return {
        "final_output": "Revised and improved draft"
    }

# Build graph
workflow = StateGraph(AgentState)

workflow.add_node("research", research_node)
workflow.add_node("outline", outline_node)
workflow.add_node("draft", draft_node)
workflow.add_node("review", review_node)
workflow.add_node("revise", revise_node)

workflow.add_edge(START, "research")
workflow.add_edge("research", "outline")
workflow.add_edge("outline", "draft")
workflow.add_edge("draft", "review")
workflow.add_conditional_edges(
    "review",
    should_continue,
    {"revise": "revise", "finalize": END}
)
workflow.add_edge("revise", "review")

app = workflow.compile()

healthcheck:
  test: ["CMD", "curl", "-f", "http://localhost:8080/health"]
  interval: 30s
  timeout: 10s
  retries: 3
  start_period: 40s

#!/bin/bash
# backup.sh - Automated VPS backup for multi-agent stack

BACKUP_DIR="/backups/multi-agent-$(date +%Y%m%d)"
mkdir -p "$BACKUP_DIR"

# Backup PostgreSQL
docker exec agents-postgres-1 pg_dump -U agentuser agents > "$BACKUP_DIR/database.sql"

# Backup ChromaDB vectors
docker cp agents-chromadb-1:/chroma/chroma "$BACKUP_DIR/chroma"

# Backup Redis dump
docker cp agents-redis-1:/data/dump.rdb "$BACKUP_DIR/"

# Compress
tar czf "$BACKUP_DIR.tar.gz" "$BACKUP_DIR"
rm -rf "$BACKUP_DIR"

# Upload to S3/R2
aws s3 cp "$BACKUP_DIR.tar.gz" "s3://agents-backups/"

# Cleanup old backups (keep 7 days)
find /backups -name "*.tar.gz" -mtime +7 -delete

echo "Backup completed: $(date)"

0 2 * * * /path/to/backup.sh >> /var/log/agent-backup.log 2>&1

# Monitor Docker container resource usage
docker stats --no-stream

# Check disk space for vector databases
du -sh /var/lib/docker/volumes/*

# Monitor API usage and costs
# Add to your .env for tracking
OPENAI_API_KEY=sk-xxxx
# Use LangSmith or LangFuse for API call tracking

# Enable UFW firewall
sudo ufw allow 22/tcp    # SSH
sudo ufw allow 443/tcp   # Cloudflare Tunnel
sudo ufw enable

# Verify
sudo ufw status