AutoGen tutorial

AutoGen ist ein fortgeschrittenes Framework von Microsoft zur Erstellung konversationeller KI-Agenten, die bei der Loesung komplexer Probleme zusammenarbeiten koennen. In diesem Tutorial zeigen wir Ihnen, wie Sie Multi-Agenten-Systeme einrichten und deren Potenzial zur Automatisierung verschiedener Aufgaben nutzen.

AutoGen: Multi-Agent-Framework fuer fortgeschrittene KI-Anwendungen¶

AutoGen ist ein Open-Source-Framework von Microsoft, das die Erstellung komplexer Multi-Agenten-Systeme mit grossen Sprachmodellen (LLM) ermoeglicht. Im Gegensatz zu einfachen Chatbots bietet AutoGen die Moeglichkeit, mehrere KI-Agenten zu orchestrieren, die miteinander kommunizieren und bei der Loesung komplexer Aufgaben zusammenarbeiten.

Schluesselkonzepte und Architektur¶

AutoGen basiert auf dem Konzept der konversationellen Agenten, bei dem jeder Agent seine Rolle, Anweisungen und Faehigkeiten hat. Der grundlegende Baustein ist die Klasse ConversableAgent, von der alle spezialisierten Agententypen erben:

• UserProxyAgent – repraesentiert einen Menschen oder ein System, das Konversationen initiiert
• AssistantAgent – KI-Agent mit Zugang zu LLM zur Generierung von Antworten
• GroupChat – orchestriert die Kommunikation zwischen mehreren Agenten

Installation und grundlegende Einrichtung¶

Um mit AutoGen zu beginnen, muessen Sie die grundlegenden Abhaengigkeiten installieren:

pip install pyautogen
# Or with extra dependencies
pip install "pyautogen[teachable]"

Als Naechstes muessen Sie den Zugang zum LLM konfigurieren. AutoGen unterstuetzt verschiedene Anbieter, darunter OpenAI, Azure OpenAI oder lokale Modelle:

import autogen

config_list = [
    {
        "model": "gpt-4-turbo",
        "api_key": "your-api-key",
        "api_type": "openai"
    }
]

llm_config = {
    "config_list": config_list,
    "temperature": 0.7,
    "timeout": 120
}

Erstellen Ihres ersten Multi-Agenten-Systems¶

Zeigen wir ein praktisches Beispiel mit zwei Agenten – einem Programmierer und einem Code-Reviewer, die bei der Erstellung und Ueberpruefung von Code zusammenarbeiten:

# Creating User Proxy agent
user_proxy = autogen.UserProxyAgent(
    name="user_proxy",
    system_message="I initiate tasks and execute code.",
    code_execution_config={
        "work_dir": "coding",
        "use_docker": False
    },
    human_input_mode="NEVER"
)

# Creating Assistant agent - Programmer
programmer = autogen.AssistantAgent(
    name="programmer",
    system_message="""You are an expert Python programmer. 
    Write clean, well-documented code according to specifications.
    Always add comments and docstrings.""",
    llm_config=llm_config
)

# Creating Assistant agent - Code Reviewer
reviewer = autogen.AssistantAgent(
    name="code_reviewer", 
    system_message="""You are a senior code reviewer. 
    Check code for errors, best practices, and optimizations.
    Provide constructive feedback.""",
    llm_config=llm_config
)

GroupChat fuer Multi-Agenten-Orchestrierung¶

Wenn wir mehr als zwei Agenten haben, verwenden wir GroupChat zur Verwaltung der Konversation:

# Creating GroupChat with multiple agents
groupchat = autogen.GroupChat(
    agents=[user_proxy, programmer, reviewer],
    messages=[],
    max_round=10,
    speaker_selection_method="round_robin"
)

# Creating Group Chat Manager
manager = autogen.GroupChatManager(
    groupchat=groupchat,
    llm_config=llm_config
)

# Starting the conversation
user_proxy.initiate_chat(
    manager,
    message="Create a Python function for email address validation using regex. Then perform a code review."
)

Erweiterte Funktionen: Custom Tools und Function Calling¶

AutoGen unterstuetzt die Integration externer Tools und APIs durch Function Calling. Agenten koennen bei Bedarf spezifische Funktionen aufrufen:

import requests
from typing import Annotated

def get_weather(city: Annotated[str, "City name"]) -> str:
    """Gets current weather for the specified city."""
    # API call simulation
    return f"In {city} it's 22°C, sunny"

def search_web(query: Annotated[str, "Search query"]) -> str:
    """Searches for information on the web."""
    return f"Results for: {query}"

# Registering functions with the agent
assistant_with_tools = autogen.AssistantAgent(
    name="assistant_with_tools",
    system_message="You are an assistant with access to external tools.",
    llm_config={
        **llm_config,
        "functions": [
            {
                "name": "get_weather",
                "description": "Gets weather for a city",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "city": {"type": "string", "description": "City name"}
                    },
                    "required": ["city"]
                }
            }
        ]
    }
)

# Registering function implementations
user_proxy.register_function(
    function_map={
        "get_weather": get_weather,
        "search_web": search_web
    }
)

Teachable Agents – Lernfaehige Agenten¶

AutoGen bietet auch TeachableAgent, der sich an fruehere Interaktionen erinnern und daraus lernen kann:

from autogen.agentchat.contrib.teachable_agent import TeachableAgent

teachable_agent = TeachableAgent(
    name="teachable_assistant",
    system_message="I am a learning assistant, I remember new information.",
    llm_config=llm_config,
    teach_config={
        "verbosity": 0,  # 0 for silent mode
        "reset_db": False,  # don't reset database on restart
        "path_to_db_dir": "./tmp/notebook",
        "use_analyzer": True
    }
)

# Agent remembers new information
user_proxy.initiate_chat(
    teachable_agent,
    message="Remember: Our main server runs on port 8080"
)

# Later the agent uses learned information
user_proxy.initiate_chat(
    teachable_agent,
    message="On which port does our main server run?"
)

Best Practices und Produktionstipps¶

Beim Einsatz von AutoGen in Produktionsumgebungen ist es wichtig, mehrere Schluesselprinzipien zu befolgen:

• Code-Sicherheit – verwenden Sie immer Docker-Container zum Ausfuehren von generiertem Code
• Rate Limiting – implementieren Sie Begrenzungen fuer die Anzahl der API-Aufrufe
• Error Handling – bereiten Sie sich auf LLM- und Netzwerkausfaelle vor
• Logging – protokollieren Sie alle Konversationen fuer Debugging und Analyse
• Kostenmonitoring – verfolgen Sie die API-Aufrufkosten

# Example of robust configuration for production
llm_config_production = {
    "config_list": config_list,
    "temperature": 0.1,  # lower temperature for more consistent results
    "timeout": 60,
    "retry_wait_time": 10,
    "max_retries": 3,
    "cache_seed": 42  # for reproducibility
}

# Safe code execution configuration
safe_execution_config = {
    "work_dir": "sandbox",
    "use_docker": True,
    "timeout": 30,
    "last_n_messages": 5  # limit context
}

Integration mit bestehenden Systemen¶

AutoGen laesst sich einfach ueber Callback-Funktionen und benutzerdefinierte Message-Handler in bestehende Anwendungen integrieren:

class CustomAgent(autogen.AssistantAgent):
    def __init__(self, **kwargs):
        super().__init__(**kwargs)
        self.message_history = []

    def receive(self, message, sender, request_reply=None, silent=False):
        # Custom logic for message processing
        self.message_history.append({
            "from": sender.name,
            "content": message.get("content", ""),
            "timestamp": time.time()
        })

        # Call parent method
        return super().receive(message, sender, request_reply, silent)

Zusammenfassung¶

AutoGen stellt einen bedeutenden Fortschritt im Bereich der Multi-Agenten-KI-Systeme dar. Es ermoeglicht die Erstellung anspruchsvoller Anwendungen, in denen verschiedene spezialisierte Agenten bei der Loesung komplexer Aufgaben zusammenarbeiten. Das Framework ist ideal fuer die Automatisierung von Code Reviews, die Generierung von Dokumentation, Datenanalyse oder die Erstellung intelligenter Assistenten. Dank seiner flexiblen Architektur und der Unterstuetzung verschiedener LLM-Anbieter eignet sich AutoGen sowohl fuer Experimente als auch fuer den Produktiveinsatz in Unternehmensumgebungen.