AutoGen Tutorial: Erstellen von Multi-Agenten-KI-Anwendungen

Die moderne KI begann mit großen Sprachmodellen (Large Language Models, LLMs), gefolgt von Funktionsaufrufen für strukturierte Ausgaben, dann der Entwicklung von Agenten und Tools, die zur Schaffung von MCP-Servern. Derzeit liegt der Schwerpunkt auf Multi-Agenten-Systemen. Unternehmen suchen nach LösungenUnternehmen suchen nach Lösungen, um intelligente automatisierte Systeme mit verschiedenen Tools zu erstellen.

In diesem Tutorium werden wir AutoGen, sein Ökosystem, seine verschiedenen Anwendungsfälle und die Verwendung der einzelnen Komponenten innerhalb dieses Ökosystems kennenlernen. Es ist wichtig zu wissen, dass AutoGen nicht nur ein typisches Sprachmodell-Orchestrierungstool wie LangChain ist; es bietet viel mehr als das.

Wenn du neu in der KI bist, belege bitte den KI-Grundlagen Lernpfad, bevor du mit diesem Lernprogramm fortfährst. Du kannst auch etwas über Agentische KI in einem separaten Artikel.

Was ist AutoGen?

AutoGen ist ein Open-Source-Framework, das für die Entwicklung von Multi-Agenten-KI-Anwendungen entwickelt wurde, die teil- und vollautonom arbeiten können. Es gibt Entwicklern Werkzeuge an die Hand, um Systeme zu bauen, in denen mehrere KI-Agenten miteinander kommunizieren, kooperieren und gemeinsam Aufgaben erfüllen können.

AutoGen unterstützt eine Vielzahl von Anwendungsfällen, darunter automatisierte Arbeitsabläufe, Zusammenarbeit mit mehreren Agenten und dynamische Aufgabenlösung. Es ermöglicht Entwicklern, Systeme zu erstellen, in denen Agenten durch natürliche Sprache interagieren, Code ausführen, Informationen abrufen und sich an komplexe Arbeitsabläufe anpassen können.

Das AutoGen-Ökosystem ist in vier Hauptkomponenten unterteilt:

1. AutoGen Studio: Eine grafische Schnittstelle ohne Code zum Erstellen und Testen von Multi-Agenten-Workflows.
2. AutoGent AgentChat: Eine vereinfachte API zur Erstellung von konversationellen Einzel- und Multi-Agenten-Anwendungen.
3. AutoGen Core: Die grundlegende API für den Aufbau skalierbarer Multi-Agenten-KI-Systeme. 
4. AutoGen-Erweiterung: Eine Bibliothek mit Erweiterungen von Erst- und Drittanbietern, die die Möglichkeiten des Frameworks erweitern.

Quelle: microsoft/AutoGen

Der AutoGen zeichnet sich aus durch seine Fähigkeit,:

• Vereinfache die Orchestrierung und Optimierung von komplexen LLM-Workflows.
• Verbessere die Leistung von LLMs und gehe dabei auf ihre Grenzen ein.
• Ermöglicht die nahtlose Erstellung von Multiagentensystemen, die LLMs, Werkzeuge und menschliche Eingaben integrieren.

Seine Erweiterbarkeit und Modularität machen es zu einem leistungsstarken Werkzeug für Entwickler in allen Branchen, vom Finanz- und Gesundheitswesen bis hin zu Bildung und Robotik.

Lies KI-Agenten verstehen: The Future of Autonomous Systems um zu erfahren, wie du KI-Agenten für Innovation und Effizienz in deinen Projekten nutzen kannst.

Erste Schritte mit dem AutoGen Ecosystem

In diesem Abschnitt werden wir die vier Hauptkomponenten des AutoGen-Ökosystems erkunden, indem wir sie lokal installieren und ausführen.

1. AutoGen Studio

AutoGen Studio ist eine Low-Code-Schnittstelle, mit der du schnell Prototypen von KI-Agenten erstellen kannst. Es bietet eine benutzerfreundliche Drag-and-Drop-Oberfläche, mit der du Multiagentensysteme erstellen und in Echtzeit testen kannst.

1. Um das Studio zu installieren, verwende den Befehl pip.

pip install -U AutoGenstudio

2. Nach der Installation kannst du die AutoGen Studio UI starten, indem du den Port und das Anwendungsverzeichnis angibst, in dem alle Agenten und Vorlagen gespeichert werden sollen. 

AutoGenstudio ui --port 8080 --appdir ./app

Nachdem du den Befehl ausgeführt hast, solltest du die folgende Ausgabe in deinem Terminal sehen:

INFO  [alembic.runtime.migration] Context impl SQLiteImpl.
INFO  [alembic.runtime.migration] Will assume non-transactional DDL.
2025-05-09 15:15:22.825 | INFO     | AutoGenstudio.web.app:lifespan:39 - Application startup complete. Navigate to http://127.0.0.1:8080

3. Navigiere in deinem Browser zu http://127.0.0.1:8080, um das Dashboard von AutoGen Studio aufzurufen.

Sobald die Anwendung gestartet ist, wirst du von einer übersichtlichen und intuitiven Benutzeroberfläche begrüßt.

AutoGen Studio bietet mehrere wichtige Funktionen, die dir helfen, Multi-Agenten-Workflows zu erstellen und zu verwalten:

1. Team Builder: Eine Drag-and-Drop-Oberfläche zum Erstellen von Agententeams.
2. Spielplatz: Eine interaktive Umgebung zum Testen und Ausführen von Agenten-Workflows.
3. Galerie: Ein zentraler Knotenpunkt zum Entdecken und Importieren von Komponenten, die von der Community erstellt wurden.
4. Laboratorien: Es handelt sich um eine experimentelle Funktion in AutoGen Studio, die es den Nutzern ermöglicht, fortschrittliche Arbeitsabläufe zu erforschen und innovative Ideen zu prototypisieren.
5. Einsetzen: Exportiere und führe Agenten-Workflows als Python-Code aus.

AutoGen Studio ist eine Low-Code-Anwendung, d.h. du kannst damit Arbeitsabläufe mit minimalem Programmieraufwand erstellen. Es bietet aber auch die Flexibilität, Agenten und Arbeitsabläufe mit Python-Code anzupassen.

2. AutoGen AgentChat

AgentChat ist ein High-Level-Framework für die Erstellung von Multi-Agenten-Konversations-Workflows. Es vereinfacht die Entwicklung von Anwendungen, bei denen mehrere Agenten (KI, Tools oder Menschen) zusammenarbeiten, um Aufgaben zu lösen. 

Installiere zunächst die benötigten Pakete:

pip install -U "AutoGen-agentchat" "AutoGen-ext[openai]"

Dann richten wir drei Agenten ein - einen Nutzer, einen Coder und einen Codeausführer -, die in einem Gruppenchat zusammenarbeiten, um Python-Code zu erzeugen, auszuführen und zu erzählen. Das System ist so konzipiert, dass es die dynamische Codegenerierung und -ausführung erleichtert und gleichzeitig menschliche Interaktion und Abbruchbedingungen zulässt.

In diesem Beispiel verwenden wir das Modell gpt-4.1-mini für die Codegenerierung, CodeExecutorAgent für die Ausführung des Befehlszeilencodes und UserProxyAgent, um die Menschen in der Schleife zu halten .

import asyncio
from pathlib import Path

from AutoGen_agentchat.agents import AssistantAgent, CodeExecutorAgent, UserProxyAgent
from AutoGen_agentchat.conditions import TextMentionTermination
from AutoGen_agentchat.teams import RoundRobinGroupChat
from AutoGen_agentchat.ui import Console
from AutoGen_ext.code_executors.local import LocalCommandLineCodeExecutor
from AutoGen_ext.models.openai import OpenAIChatCompletionClient

async def main() -> None:
    model_client = OpenAIChatCompletionClient(model="gpt-4.1-mini")

    coder = AssistantAgent(
        "coder",
        model_client=model_client,
        system_message=(
            "You are a senior engineer. Think step-by-step, then output ONLY runnable "
            "Python inside ```pythonthon``` blocks—no commentary."
        ),
    )

    executor = CodeExecutorAgent(
        "executor",
        model_client=model_client,  # lets it narrate results
        code_executor=LocalCommandLineCodeExecutor(work_dir=Path.cwd() / "runs"),
    )

    user = UserProxyAgent("user")  # human in the loop

    termination = TextMentionTermination("exit", sources=["user"])
    team = RoundRobinGroupChat(
        [user, coder, executor], termination_condition=termination
    )

    try:
        await Console(
            team.run_stream()
        )
    finally:
        await model_client.close()

if __name__ == "__main__":
    asyncio.run(main())

Speichere den obigen Code in einer Datei chat_app.py, und führe ihn mit aus:

python chat_app.py 

Wir haben die Agentenanwendung gebeten, den Code für das Drucken der Sterne in Dreiecksform zu generieren und den Code dann auszuführen. 

Sie hat den Code erfolgreich generiert und ausgeführt und dabei auch zusätzliche Optionen angeboten. Der/die Nutzer/in kann "exit" eingeben, um zu beenden oder Folgefragen stellen, um ein Gespräch zu führen.

Ausgabe: 

Enter your response: Write a Python script that prints stars and run it.
---------- TextMessage (user) ----------
Write a Python script that prints stars and run it.

---------- TextMessage (coder) ----------
# Print a simple star pattern
for i in range(1, 6):
    print('*' * i)

---------- CodeGenerationEvent (executor) ----------
# Print a simple star pattern
for i in range(1, 6):
    print('*' * i)

---------- CodeExecutionEvent (executor) ----------

*

**

***

****

*****

---------- TextMessage (executor) ----------

The star pattern has been printed successfully. If you'd like a different pattern or further modifications, just let me know!

Enter your response:

3. AutoGen Kern

Der AutoGen Core ist ein Low-Level-Framework, das eine leistungsstarke Methode zur Erstellung und Verwaltung von Multi-Agenten-Systemen bietet. 

In diesem Beispiel werden wir zwei Agenten erstellen: einen Echo-Agenten, der den Inhalt einer Nachricht umkehrt, und einen Drucker-Agenten, der den Inhalt der Nachricht auf der Konsole ausgibt.

pip install "autogen-core"

Komponenten, die in dieser Anwendung verwendet werden:

1. Struktur der Nachricht: Die Klasse Text ist eine einfache Datenstruktur, die den Inhalt einer Nachricht enthält.

2. Echo Agent: Der Agent Echo kehrt den Inhalt jeder Nachricht um, die er erhält, und veröffentlicht die umgekehrte Nachricht im Standard-Topic unter publish_message.

3. Drucker-Agent: Der Printer Agent lauscht auf Nachrichten und gibt deren Inhalt auf der Konsole aus.

4. Laufzeit: Die SingleThreadedAgentRuntime wird verwendet, um den Lebenszyklus der Agenten zu verwalten und die Nachrichtenweiterleitung zu übernehmen.

import asyncio
from dataclasses import dataclass

from AutoGen_core import (
    AgentId,
    DefaultTopicId,
    MessageContext,
    RoutedAgent,
    SingleThreadedAgentRuntime,
    default_subscription,
    message_handler,
)

@dataclass
class Text:
    content: str

@default_subscription
class Echo(RoutedAgent):
    def __init__(self) -> None:
        super().__init__("echo")

    @message_handler
    async def handle(self, message: Text, ctx: MessageContext) -> None:  # param must be named 'message'
        await self.publish_message(Text(message.content[::-1]), DefaultTopicId())

@default_subscription
class Printer(RoutedAgent):
    def __init__(self) -> None:
        super().__init__("printer")

    @message_handler
    async def handle(self, message: Text, ctx: MessageContext) -> None:  # param must be named 'message'
        print(message.content)

async def main() -> None:
    rt = SingleThreadedAgentRuntime()
    await Echo.register(rt, "echo", lambda: Echo())
    await Printer.register(rt, "printer", lambda: Printer())
    rt.start()
    await rt.send_message(Text("DataCamp"), AgentId("echo", "default"))
    await rt.stop_when_idle()

if __name__ == "__main__":
    asyncio.run(main())

Speichere den Code in einer Datei core_app.py, und führe ihn mit aus:

python core_app.py            

Nachrichtenfluss:

• Eine Nachricht mit dem Inhalt "DataCamp" wird an den Echo-Agenten gesendet.
• Der Echo-Agent wandelt die Nachricht in "pmaCataD" um und veröffentlicht sie.
• Der Drucker-Agent empfängt die umgekehrte Nachricht und druckt sie auf der Konsole aus.

Ausgabe: 

pmaCataD

4. AutoGen-Erweiterungen

Das AutoGen Extensions Framework bietet Erweiterungen von Erst- und Drittanbietern, die die Möglichkeiten des Frameworks erweitern. 

In diesem Beispiel zeigen wir dir, wie du den MultimodalWebSurfer Agenten verwendest, der mit Webseiten interagieren, Suchen durchführen und Informationen extrahieren kann .

Bevor du das Beispiel ausführst, stelle sicher, dass du Playwright installiert hast:

playwright install 

So funktioniert der Code: 

1. Initialisierung des Agenten: Es wird ein MultimodalWebSurfer Agent erstellt, der das gpt-4.1-mini Modell von OpenAI für die Entscheidungsfindung und einen Browser (über Playwright) für Webinteraktionen nutzt.
2. Teamaufstellung: Der Agent wird einem RoundRobinGroupChat Team hinzugefügt, das den Arbeitsablauf des Agenten verwaltet und die Aufgabe auf 3 Runden begrenzt.
3. Aufgabenausführung: Das Team erhält die Anweisung, die Aufgabe auszuführen: "Gehe zu Google und suche nach Abid Ali Awan." Der Agent öffnet einen Browser, navigiert zu Google, führt die Suche durch und extrahiert relevante Informationen.
4. Streaming-Ausgang: Die Aktionen des Agenten (z. B. das Navigieren zu einer Seite, das Klicken auf Links, das Extrahieren von Metadaten) werden in Echtzeit an die Konsole übertragen.
5. Aufräumen: Nachdem die Aufgabe abgeschlossen ist, wird der Browser geschlossen, um Ressourcen freizugeben.

import asyncio
from AutoGen_agentchat.ui import Console
from AutoGen_agentchat.teams import RoundRobinGroupChat
from AutoGen_ext.models.openai import OpenAIChatCompletionClient
from AutoGen_ext.agents.web_surfer import MultimodalWebSurfer

async def main() -> None:
    # Define an agent
    web_surfer_agent = MultimodalWebSurfer(
        name="MultimodalWebSurfer",
        model_client=OpenAIChatCompletionClient(model="gpt-4.1-mini"),
    )

    # Define a team
    agent_team = RoundRobinGroupChat([web_surfer_agent], max_turns=3)

    # Run the team and stream messages to the console
    stream = agent_team.run_stream(task="Navigate to Google and search about Abid Ali Awan.")
    await Console(stream)
    # Close the browser controlled by the agent
    await web_surfer_agent.close()

asyncio.run(main())

Speichere den Code in einer Datei, web_ext_app.py, und führe ihn mit aus:

python web_ext_app.py          

Wenn du die Anwendung ausführst, kommt es zu den folgenden Interaktionen:

                                                           
---------- TextMessage (user) ----------
Navigate to Google and search about Abid Ali Awan.
---------- MultiModalMessage (MultimodalWebSurfer) ----------
I typed 'https://www.google.com' into the browser address bar.

The web browser is open to the page [Google](https://www.google.com/).
The viewport shows 100% of the webpage, and is positioned at the top of the page
The following text is visible in the viewport:

Gmail
Images
Sign in
Google offered in:
اردو
پښتو
سنڌيPakistan
About
Advertising
Business
 How Search works
Privacy
Terms
Settings
Google recommends using Chrome
Try a fast, secure browser with updates built in
Don't switch
Yes

The following metadata was extracted from the webpage:

{
    "microdata": [
        {
            "itemType": "http://schema.org/WebPage",
            "image": "/images/branding/googleg/1x/googleg_standard_color_128dp.png"
        }
    ],
    "meta_tags": {
        "referrer": "origin"
    }
}

Here is a screenshot of the page.
<image>
---------- MultiModalMessage (MultimodalWebSurfer) ----------
I clicked 'Sign in'.

The web browser is open to the page [Sign in - Google Accounts](https://accounts.google.com/v3/signin/identifier?continue=https%3A%2F%2Fwww.google.com%2F&ec=futura_exp_og_so_72776762_e&hl=en&ifkv=ASKV5MhAzFZnwDH-Aw10tuqQN1ppsY8OZ2-OJ3YavFHXMDlX9iTddg1d_k78ZZ0SogFUivcY7Td0Hg&passive=true&flowName=GlifWebSignIn&flowEntry=ServiceLogin&dsh=S1980923188%3A1746809726624486).
The viewport shows 100% of the webpage, and is positioned at the top of the page
The following text is visible in the viewport:

Sign inUse your Google AccountEmail or phone
Forgot email?
Not your computer? Use a private browsing window to sign in.
Learn more about using Guest modeNext
Create account
English (United States)
Help
Privacy
Terms
Sign in Use your Google Account

The following metadata was extracted from the webpage:

{
    "meta_tags": {
        "referrer": "origin",
        "chrome": "nointentdetection",
        "viewport": "width=device-width, initial-scale=1",
        "description": ""
    }
}

Here is a screenshot of the page.
<image>
---------- TextMessage (MultimodalWebSurfer) ----------
Please provide the email or phone number you want to use to sign in, or let me know if you want to create a new account or need help with something else on this page.

Ähnlich wie AutoGen ist CrewAI ein weiteres bei KI-Fans beliebtes Framework zur Erstellung von agentenbasierten Arbeitsabläufen. Folge der CrewAI: A Guide With Examples of Multi AI Agent Systems tutorial, um mehr darüber zu erfahren.

AutoGen Anwendungsfälle

AutoGen eröffnet zahlreiche Möglichkeiten für die Erstellung intelligenter Multiagentensysteme. Hier sind einige der wichtigsten Anwendungsfälle des AutoGen-Ökosystems:

1. Codegenerierung, -ausführung und -debugging: Automatisiert Kodieraufgaben, reduziert Fehler und verbessert die Effizienz.
2. Zusammenarbeit von Multi-Agenten: Ermöglicht Teamarbeit zwischen Agenten, um komplexe Aufgaben zu lösen.
3. Sequentielle Multi-Agenten-Chats: Verwaltet strukturierte Aufgabenabläufe für eine effiziente Erledigung.
4. Verschachtelte Chats: Erledigt komplizierte Aufgaben durch detaillierte, vielschichtige Gespräche.
5. Werkzeuggebrauch: Erweitert die Agentenfunktionalität durch die Integration von Tools wie Websuche und SQL-Abfragen.
6. Menschliches Engagement: Bezieht menschliches Feedback ein, um Arbeitsabläufe zu verbessern.
7. Agenten lehren und lernen: Verbessert die Fähigkeiten und Kenntnisse der Agenten.
8. Multi-Agenten-Chat mit OpenAI-Assistenten: Kombiniert OpenAI-Funktionen mit AutoGen für fortgeschrittene Aufgaben.
9. Multimodaler Agent: Verarbeitet Text, Bilder und andere Medien für reichhaltigere Interaktionen.
10. Lange Kontextbehandlung: Bleibt in längeren Gesprächen zusammenhängend.

Fazit

Es gibt einen Grund, warum AutoGen so viel Aufmerksamkeit und Anerkennung erlangt hat und sich einen Platz als eines der meistbeachteten Agentic-Frameworks auf GitHub verdient hat. 

Es ist ein umfassendes Framework, das sich an alle richtet, von professionellen Entwicklern bis hin zu Gelegenheits-Programmierern und sogar an Personen, die keine Erfahrung im Programmieren haben. 

Mit AutoGen kannst du mit AutoGen Studio schnell Prototypen von Workflows erstellen, mit dem Core Framework und den Extensions robuste Anwendungen entwickeln und diese nahtlos in der Cloud bereitstellen. Es ist eine echte All-in-One-Lösung für die Erstellung und Verwaltung intelligenter Multiagentensysteme.

Nimm die Dynamische LangChain-Agenten erstellen und lerne, wie du deine erste KI-Agentenanwendung mit dem beliebten LLM-Framework erstellst.