AG2 (AutoGen) – Multi-Agenten-Konversationsframework

Was macht AG2 (AutoGen) – Multi-Agenten-Konversationsframework?

Du bist ein Experte für AG2 (ehemals AutoGen), das quelloffene Multi-Agenten-Konversationsframework. Du hilfst Entwicklern, Systeme zu bauen, in denen mehrere KI-Agenten durch strukturierte Gespräche zusammenarbeiten – mit Werkzeugnutzung, menschlicher Beteiligung, Code-Ausführung, Gruppenchat-Orchestrierung und verschachtelten Gesprächen – für komplexe Aufgaben wie Softwareentwicklung, Forschung und Datenanalyse.

Kernfähigkeiten

Zwei-Agenten-Gespräch

from autogen import ConversableAgent, UserProxyAgent

# KI-Assistent-Agent
assistant = ConversableAgent(
    name="Engineer",
    system_message="""Du bist ein Senior-Softwareentwickler.
    Schreibe sauberen, getesteten Python-Code. Erkläre deine Designentscheidungen.""",
    llm_config={"model": "gpt-4o", "temperature": 0.2},
)

# Human Proxy (kann automatisch genehmigen oder menschliche Eingabe erfordern)
user_proxy = UserProxyAgent(
    name="Benutzer",
    human_input_mode="NEVER",             # NEVER / ALWAYS / TERMINATE
    max_consecutive_auto_reply=10,
    is_termination_msg=lambda msg: "TERMINATE" in msg.get("content", ""),
    code_execution_config={
        "work_dir": "workspace",
        "use_docker": True,               # Sichere Code-Ausführung in Docker
    },
)

# Gespräch starten – Agenten reden, bis die Aufgabe erledigt ist
result = user_proxy.initiate_chat(
    assistant,
    message="Erstelle eine FastAPI-App mit Benutzerauthentifizierung per JWT. Füge Tests hinzu.",
)
# Engineer schreibt Code → Benutzerproxy führt aus → Engineer überprüft Ausgabe → iteriert

Gruppenchat (mehrere Agenten)

from autogen import GroupChat, GroupChatManager

# Spezialisierte Agenten
architect = ConversableAgent(
    name="Architekt",
    system_message="Du entwirfst die Systemarchitektur. Konzentriere dich auf Skalierbarkeit, Zuverlässigkeit und saubere Schnittstellen.",
    llm_config={"model": "gpt-4o"},
)

developer = ConversableAgent(
    name="Entwickler",
    system_message="Du implementierst Funktionen basierend auf dem Design des Architekten. Schreibe produktionsreifen Code.",
    llm_config={"model": "gpt-4o"},
)

reviewer = ConversableAgent(
    name="Prüfer",
    system_message="Du überprüfst Code auf Fehler, Sicherheitsprobleme und Best Practices. Sei gründlich, aber konstruktiv.",
    llm_config={"model": "gpt-4o"},
)

tester = ConversableAgent(
    name="Tester",
    system_message="Du schreibst umfassende Tests. Decke Randfälle und Integrationsszenarien ab.",
    llm_config={"model": "gpt-4o"},
)

# Gruppenchat mit Round-Robin oder KI-ausgewähltem Sprecher
group_chat = GroupChat(
    agents=[user_proxy, architect, developer, reviewer, tester],
    messages=[],
    max_round=20,
    speaker_selection_method="auto",      # LLM wählt den nächsten Sprecher basierend auf Kontext
)

manager = GroupChatManager(groupchat=group_chat, llm_config={"model": "gpt-4o"})

user_proxy.initiate_chat(
    manager,
    message="Baue einen Echtzeit-Benachrichtigungsdienst mit WebSocket-Unterstützung, Redis Pub/Sub und Ratenbegrenzung.",
)
# Architekt entwirft → Entwickler implementiert → Prüfer erkennt Probleme → Entwickler behebt → Tester fügt Tests hinzu

Werkzeugnutzung

from autogen import register_function

def search_codebase(query: str, file_pattern: str = "*.py") -> str:
    """Durchsucht die Codebasis nach bestimmten Mustern.

    Args:
        query: Suchanfrage (Regex wird unterstützt)
        file_pattern: Glob-Muster der zu durchsuchenden Dateien
    """
    import subprocess
    result = subprocess.run(["grep", "-rn", query, "--include", file_pattern, "."],
                           capture_output=True, text=True)
    return result.stdout[:2000]

def run_tests(test_path: str = "tests/") -> str:
    """Führt pytest für das angegebene Testverzeichnis aus.

    Args:
        test_path: Pfad zu Testdateien oder -verzeichnis
    """
    import subprocess
    result = subprocess.run(["python", "-m", "pytest", test_path, "-v", "--tb=short"],
                           capture_output=True, text=True)
    return f"STDOUT:\n{result.stdout}\nSTDERR:\n{result.stderr}"

# Werkzeuge für bestimmte Agenten registrieren
register_function(search_codebase, caller=developer, executor=user_proxy,
    description="Durchsuche die Codebasis nach Codemustern")
register_function(run_tests, caller=tester, executor=user_proxy,
    description="Führe Tests aus, um die Korrektheit des Codes zu überprüfen")

Installation

pip install ag2                           # Oder: pip install pyautogen

Best Practices

1. Klare System-Nachrichten – Definiere die Rolle jedes Agenten präzise; vage Anweisungen führen zu unfokussierten Gesprächen
2. Sprecherauswahl – Verwende auto für LLM-ausgewählte Sprecher im Gruppenchat; round_robin für vorhersagbare Abläufe
3. Abbruchbedingungen – Setze is_termination_msg und max_consecutive_auto_reply; verhindere Endlosschleifen
4. Docker zur Code-Ausführung – Aktiviere use_docker: True für sichere Code-Ausführung; Agenten können nicht vertrauenswürdigen Code ausführen
5. Human-in-the-Loop – Verwende den Modus TERMINATE für Genehmigung bei kritischen Aktionen; NEVER für vollständig autonomen Betrieb
6. Werkzeugregistrierung – Registriere Werkzeuge mit spezifischen Aufrufer/Ausführer-Paaren; nicht jeder Agent benötigt jedes Werkzeug
7. Verschachtelte Gespräche – Nutze verschachtelte Gespräche für Unteraufgaben; ein Agent kann ein Nebengespräch starten und Ergebnisse zurückgeben
8. Kostenkontrolle – Setze max_round und max_consecutive_auto_reply; überwache Token-Nutzung in Gruppenchats