microsoft/autogen: Multi-Agent AI Framework

# For new projects, consider Microsoft Agent Framework instead:
# https://github.com/microsoft/agent-framework
# Migration guide: https://learn.microsoft.com/en-us/agent-framework/migration-guide/from-autogen/

# Check Python version (3.10+ required)
python3 --version

# Check pip (or install uv as modern alternative)
pip --version
uv --version  # Optional: faster package manager

# Optional: Docker for code execution sandboxing
docker --version

# Optional: Node.js for AutoGen Studio
node --version  # For frontend components
npm --version

AutoGen Package Structure:
├── autogen-core (0.7.5)
│   ├── Event-driven agents
│   ├── Message passing
│   ├── Local/distributed runtime
│   └── Cross-language support (.NET/Python)
├── autogen-agentchat (0.7.5)
│   ├── Simpler API
│   ├── Two-agent chat
│   ├── Group chats
│   └── Built on Core
└── autogen-ext (0.7.5)
    ├── LLM clients
    ├── MCP support
    ├── Code execution
    └── External integrations

# Create a project directory
mkdir autogen-demo
cd autogen-demo

# Create virtual environment (recommended)
python3 -m venv .venv
source .venv/bin/activate  # Linux/macOS

# Windows: .venv\Scripts\activate

# Install core packages with OpenAI support
pip install -U "autogen-agentchat" "autogen-ext[openai]"

# Verify installation
python -c "import autogen_agentchat; print('AutoGen AgentChat installed')"
python -c "import autogen_core; print('AutoGen Core installed')"

# OpenAI (GPT-4o, GPT-3.5)
export OPENAI_API_KEY="your-api-key-here"

# Azure OpenAI (enterprise)
export AZURE_API_KEY="your-azure-key"
export AZURE_API_VERSION="2024-02-01"
export AZURE_DEPLOYMENT_NAME="gpt-4o"

# Anthropic (Claude models)
export ANTHROPIC_API_KEY="your-anthropic-key"

# Ollama (local models - no API key needed)
# Download from https://ollama.ai
# Then run: ollama pull llama3.2

# For development, use a .env file (install python-dotenv first)
echo "OPENAI_API_KEY=your-api-key-here" > .env
pip install python-dotenv

import asyncio
from autogen_agentchat.agents import AssistantAgent
from autogen_ext.models.openai import OpenAIChatCompletionClient

async def main() -> None:
    # Create model client
    model_client = OpenAIChatCompletionClient(model="gpt-4o")
    
    # Create assistant agent
    agent = AssistantAgent("assistant", model_client=model_client)
    
    # Run a task
    result = await agent.run(task="Say 'Hello World!'")
    print(result)
    
    # Close the connection
    await model_client.close()

# Run the async function
asyncio.run(main())

import asyncio
from autogen_agentchat.agents import AssistantAgent
from autogen_agentchat.tools import AgentTool
from autogen_agentchat.ui import Console
from autogen_ext.models.openai import OpenAIChatCompletionClient

async def main() -> None:
    model_client = OpenAIChatCompletionClient(model="gpt-4o")

    # Create specialized agents
    math_agent = AssistantAgent(
        "math_expert",
        model_client=model_client,
        system_message="You are a math expert.",
        description="A math expert assistant.",
        model_client_stream=True,
    )
    
    chemistry_agent = AssistantAgent(
        "chemistry_expert",
        model_client=model_client,
        system_message="You are a chemistry expert.",
        description="A chemistry expert assistant.",
        model_client_stream=True,
    )
    
    # Create tools for the agents
    math_tool = AgentTool(math_agent, return_value_as_last_message=True)
    chemistry_tool = AgentTool(chemistry_agent, return_value_as_last_message=True)
    
    # Create a coordinator agent with tools
    coordinator = AssistantAgent(
        "coordinator",
        system_message="You are a general assistant. Use expert tools when needed.",
        model_client=model_client,
        tools=[math_tool, chemistry_tool],
        max_tool_iterations=10,
    )
    
    # Run tasks with multi-agent collaboration
    await Console(coordinator.run_stream(task="What is the integral of x^2?"))
    await Console(coordinator.run_stream(task="What is the molecular weight of water?"))
    
    # Clean up connections
    await model_client.close()

asyncio.run(main())

# Install AutoGen Studio
pip install -U autogenstudio

# Launch the web UI on port 8080
autogenstudio ui --port 8080 --appdir ./my-app

# Open browser to http://localhost:8080

# Note: AutoGen Studio is for prototyping, not production
# It does not include authentication or security features

import asyncio
from autogen_agentchat.agents import AssistantAgent
from autogen_agentchat.ui import Console
from autogen_ext.models.openai import OpenAIChatCompletionClient
from autogen_ext.tools.mcp import McpWorkbench, StdioServerParams

async def main() -> None:
    model_client = OpenAIChatCompletionClient(model="gpt-4o")
    
    # Configure MCP server (Playwright for web browsing)
    server_params = StdioServerParams(
        command="npx",
        args=["@playwright/mcp@latest", "--headless"],
    )
    
    async with McpWorkbench(server_params) as mcp:
        agent = AssistantAgent(
            "web_browsing_assistant",
            model_client=model_client,
            workbench=mcp,
            model_client_stream=True,
            max_tool_iterations=10,
        )
        await Console(
            agent.run_stream(task="Count stars in microsoft/autogen repository on GitHub")
        )

asyncio.run(main())

from autogen_core.code_executor import DockerCommandLineCodeExecutor

# Using Docker for safe code execution (RECOMMENDED)
async with DockerCommandLineCodeExecutor(
    image_name="python:3.11",
    work_dir="/tmp",
) as code_executor:
    result = await code_executor.execute_code_block(
        code="print('Hello from sandboxed environment')"
    )
    print(f"Output: {result.output}")

# Using local execution (NOT recommended for production)
from autogen_core.code_executor import CommandLineCodeExecutor
async with CommandLineCodeExecutor() as local_executor:
    result = await local_executor.execute_code_block(code="print('Local execution')")

import asyncio
import os
from dotenv import load_dotenv
from autogen_agentchat.agents import AssistantAgent
from autogen_ext.models.openai import OpenAIChatCompletionClient

# Load environment variables
load_dotenv()

async def create_agent() -> AssistantAgent:
    api_key = os.getenv("OPENAI_API_KEY")
    if not api_key:
        raise ValueError("OPENAI_API_KEY not set")
    
    model_client = OpenAIChatCompletionClient(
        model="gpt-4o",
        api_key=api_key,
        max_tokens=1024
    )
    
    agent = AssistantAgent(
        "production_assistant",
        model_client=model_client,
        system_message="You are a helpful, safe AI assistant.",
        description="Production-grade assistant agent",
        max_tool_iterations=10,
        model_client_stream=True,
    )
    return agent, model_client

async def main():
    try:
        agent, model_client = await create_agent()
        result = await agent.run(task="Create a simple Python function")
        print(f"Result: {result}")
    except Exception as e:
        print(f"Error: {e}")
    finally:
        if model_client:
            await model_client.close()

# Test 1: Verify packages are installed
python3 << 'EOF'
import autogen_core
import autogen_agentchat
print("Core packages installed")

try:
    from autogen_ext.models.openai import OpenAIChatCompletionClient
    print("OpenAI integration available")
except ImportError:
    print("OpenAI integration missing")
    
try:
    from autogen_core.code_executor import DockerCommandLineCodeExecutor
    print("Docker code execution available")
except ImportError:
    print("Docker execution missing")
EOF

autogen-core==0.7.5
autogen-agentchat==0.7.5
autogen-ext[openai,docker]==0.7.5
python-dotenv
fastapi
uvicorn

# Azure (enterprise deployment)
pip install "autogen-ext[azure]"

# Anthropic (Claude models)
pip install "autogen-ext[anthropic]"

# Google Gemini
pip install "autogen-ext[gemini]"

# Ollama (local models)
pip install "autogen-ext[ollama]"

# Llama.cpp (local, low-latency)
pip install "autogen-ext[llama-cpp]"

# File processing and analysis
pip install "autogen-ext[file-surfer] autogen-ext[web-surfer]"

# Code execution
pip install "autogen-ext[docker]"

# Memory and knowledge graphs
pip install "autogen-ext[chromadb] autogen-ext[graphrag]"

# Semantic Kernel integration
pip install "autogen-ext[semantic-kernel-core]"

# Memory with ChromaDB
from autogen_ext.memory.chromadb import ChromaDBMemory
from autogen_agentchat.agents import AssistantAgent

# Install: pip install "autogen-ext[chromadb]"

chroma_memory = ChromaDBMemory(collection_name="agent_memory")

agent = AssistantAgent(
    "remembering_agent",
    model_client=model_client,
    memory=chroma_memory,
    system_message="Remember user preferences and past conversations."
)

# Knowledge Graph with GraphRAG
# Install: pip install "autogen-ext[graphrag]"
from autogen_ext.graphrag import GraphRAGIndexer, GraphRAGQueryEngine
from autogen_agentchat.tools import AgentTool

indexer = GraphRAGIndexer(graphrag_config_path="config.yaml")
query_engine = GraphRAGQueryEngine(indexer=indexer)

agent = AssistantAgent(
    "knowledge_agent",
    model_client=model_client,
    tools=[AgentTool(query_engine)]
)

Issue: API key errors
Solution: Check OPENAI_API_KEY is set and valid:
  export OPENAI_API_KEY="sk-..."

Issue: Docker execution fails
Solution: Ensure Docker is running and python-docker is installed:
  pip install docker
  docker ps  # Verify Docker daemon

Issue: Async programming errors
Solution: AutoGen 0.7+ uses async/await. Ensure you run:
  asyncio.run(main())
  NOT: main()

Issue: Missing optional dependencies
Solution: Install specific extras:
  pip install "autogen-ext[openai] autogen-ext[docker]"

Issue: AutoGen Studio won't start
Solution: Clear appdir and reinstall:
  rm -rf ./myapp
  pip install --upgrade --force-reinstall autogenstudio

Issue: Model compatibility errors
Solution: Check supported models in documentation. GPT-4o is recommended.

Issue: Network timeouts
Solution: Increase connection timeout:
  OpenAIChatCompletionClient(
      model="gpt-4o",
      timeout=30
  )

Issue: Migration from v0.2
Solution: Review migration guide:
  https://github.com/microsoft/autogen/blob/main/MIGRATION-GUIDE.md