Key Findings
  • AI Agents entwickeln sich von passiven Frage-Antwort-Systemen zu autonomen Systemen, die ihre Umgebung wahrnehmen, Schritte planen, Tools aufrufen und sich selbst reflektieren. Das ReAct-Framework verbindet Reasoning und Acting und ist derzeit das vorherrschende Agent-Designmuster
  • LangGraph basiert auf einer gerichteten Graphen-Zustandsmaschine und bietet die feinkoernigste Kontrolle -- ideal fuer produktionsreife Anwendungen, die eine praezise Definition des Ausfuehrungsablaufs erfordern. CrewAI setzt auf Rollenspiel und Aufgabendelegation und bietet die schnellste Entwicklungsgeschwindigkeit, jedoch weniger Flexibilitaet
  • AutoGen (jetzt AG2) nutzt eine dialoggesteuerte Multi-Agenten-Architektur und eignet sich am besten fuer Szenarien, die tiefgehende Verhandlungen zwischen Agenten erfordern -- hat jedoch eine steilere Lernkurve und hoehere Debugging-Komplexitaet
  • Dieser Artikel enthaelt zwei vollstaendige Google Colab Implementierungen: einen ReAct Tool-Calling Agent mit LangGraph und ein Multi-Agent-Forschungsteam mit CrewAI -- beide mit einem Klick ausfuehrbar

1. Vom Chatbot zum autonomen Agenten: Der Paradigmenwechsel der AI Agents

Im Jahr 2023 drangen Large Language Models (LLMs) mit erstaunlicher Geschwindigkeit in saemtliche Branchen vor. Dennoch verharren die meisten Anwendungen im Modus "Mensch fragt, KI antwortet" -- ein Dialogmuster, das sich im Nutzungsparadigma kaum grundlegend von einer herkoemmlichen Suchmaschine unterscheidet. Der eigentliche Durchbruch liegt darin: Wenn wir einem LLM die Faehigkeit verleihen, seine Umgebung wahrzunehmen, Schritte zu planen, externe Tools aufzurufen und sich anhand der Ergebnisse selbst zu korrigieren, verwandelt es sich von einem passiven Sprachmodell in einen autonomen AI Agent[1].

Wang et al. definierten in ihrer 2024 veroeffentlichten Uebersichtsstudie[1] den LLM-basierten Agent als ein autonomes System mit einem LLM als kognitivem Kern und vier Kernmodulen: Wahrnehmung (Perception), Planung (Planning), Handlung (Action) und Gedaechtnis (Memory). Diese Definition erfasst praezise den wesentlichen Unterschied zwischen Agents und herkoemmlichen Chatbots -- Agents koennen nicht nur Fragen beantworten, sondern proaktiv mit der Aussenwelt interagieren und mehrstufige Aufgaben erledigen.

Aus der Perspektive der industriellen Praxis liegt der Wert von Agents darin, dass sie Menschen von repetitiver kognitiver Arbeit befreien koennen. Ein gut konzipierter Agent kann eigenstaendig Marktrecherchen, Datenanalysen, Berichterstellung, Codegenerierung und andere komplexe Aufgaben ausfuehren -- Arbeiten, die einen Analysten zuvor Stunden kosteten, erledigt ein Agent in wenigen Minuten. Die Forschung zu "Generative Agents" von Park et al.[7] demonstrierte darueber hinaus die Faehigkeit sozialer Interaktion zwischen Agents und deutete das enorme Potenzial der Multi-Agenten-Kollaboration an.

Allerdings ist der Aufbau eines zuverlaessigen AI Agent keineswegs so einfach wie "ein LLM mit ein paar APIs zu verbinden". Die zentralen Herausforderungen bei Agents sind: Wie stellt man die Konsistenz des LLM bei mehrstufigem Reasoning sicher? Wie geht man elegant mit fehlgeschlagenen Tool-Aufrufen und Wiederholungsversuchen um? Wie koordiniert man den Informationsfluss und die Entscheidungsbefugnisse zwischen mehreren Agents? Diese technischen Herausforderungen fuehrten zur Entstehung einer Reihe von Agent-Entwicklungsframeworks, wobei LangGraph, CrewAI und AutoGen derzeit die drei repraesentativsten Optionen darstellen.

2. Kernarchitektur eines Agent: Perceive, Plan, Act, Reflect

Bevor wir die drei Frameworks im Detail vergleichen, muessen wir zunaechst die allgemeinen Architekturmuster von AI Agents verstehen. Unabhaengig vom verwendeten Framework umfasst ein vollstaendiges Agent-System vier Kernphasen[1]:

2.1 Wahrnehmung (Perceive)

Ein Agent muss zunaechst die aktuelle Aufgabenumgebung verstehen. Dazu gehoeren: das Parsen der natuerlichsprachlichen Eingabe des Benutzers, das Lesen externer Datenquellen (Datenbanken, APIs, Dokumente) sowie das Abrufen des Kontextgedaechtnisses aus vorherigen Dialogrunden. Die Qualitaet des Wahrnehmungsmoduls bestimmt unmittelbar die Genauigkeit der nachfolgenden Entscheidungen des Agent.

2.2 Planung (Plan)

Dies ist die zentrale Komponente der Agent-Architektur. Basierend auf den wahrgenommenen Informationen plant das LLM eine Schrittfolge zur Aufgabenerfuellung. Die von Wei et al. vorgeschlagene Chain-of-Thought-Methode (CoT)[3] bildet die Grundlage der Planung -- durch schrittweises Reasoning kann das LLM komplexe Aufgaben in ausfuehrbare Teilaufgaben zerlegen. Das ReAct-Framework von Yao et al.[2] geht noch weiter und verwebt Reasoning und Acting zu einem Zyklus aus "Denken - Handeln - Beobachten - erneut Denken".

Die zentrale Erkenntnis von ReAct lautet: Das LLM muss nicht alle Schritte auf einmal planen, sondern kann nach jeder Aktion seine weitere Planung dynamisch anhand der beobachteten Ergebnisse anpassen. Diese Strategie des "Denkens waehrend des Handelns" verbessert die Robustheit von Agents in unsicheren Umgebungen erheblich.

2.3 Handlung (Act)

Nach Abschluss der Planung muss der Agent die Handlungen tatsaechlich ausfuehren. Im Kontext von LLM-basierten Agents bedeutet "Handlung" typischerweise den Aufruf externer Tools (Tool Calling / Function Calling). Die Forschung von Qin et al.[8] sowie das von Schick et al. vorgestellte Toolformer-System[9] untersuchten systematisch die Faehigkeit von LLMs, den Umgang mit Tools zu erlernen. Typische Tools umfassen: Suchmaschinen, Taschenrechner, Code-Ausfuehrungsumgebungen, Datenbankabfragen, API-Aufrufe und mehr.

Die zentrale Herausforderung beim Tool Calling besteht darin, dass das LLM praezise die vom Tool benoetigten strukturierten Eingaben erzeugen muss (z.B. Funktionsparameter im JSON-Format) und die Rueckgabeergebnisse des Tools korrekt interpretieren muss. Die Gorilla-Studie von Patil et al.[13] demonstrierte die Machbarkeit, die Genauigkeit von LLM-Tool-Aufrufen durch Feinabstimmung zu verbessern.

2.4 Reflexion (Reflect)

Schliesslich sollte ein ausgereifter Agent die Faehigkeit zur Selbstreflexion besitzen. Das von Shinn et al. vorgeschlagene Reflexion-Framework[4] ermoeglicht es Agents durch einen sprachbasierten Selbstfeedback-Mechanismus, aus Fehlern zu lernen und bei nachfolgenden Versuchen wiederholte Fehler zu vermeiden. Diese Methode des "sprachlichen Reinforcement Learning" erfordert keine Aktualisierung der Modellgewichte und kann allein durch Prompt Engineering umgesetzt werden -- mit aeusserst hohem praktischem Nutzen.

Die folgende Abbildung zeigt den typischen Ausfuehrungsablauf eines ReAct Agent:

Benutzerfrage: "Wie hoch war der Umsatz von TSMC im Q4 2025? Wie stark ist er im Vergleich zum Vorquartal gewachsen?"

[Denken] Ich muss die Finanzdaten von TSMC abfragen und zuerst den aktuellen Umsatzbericht suchen.
[Handeln] Aufruf search_tool("TSMC 2025 Q4 Umsatzbericht")
[Beobachten] Suchergebnis zeigt: TSMC Q4 2025 Umsatz betrug 868,4 Mrd. TWD.
[Denken] Ich habe den Q4-Umsatz erhalten, jetzt brauche ich die Q3-Daten zur Berechnung der Wachstumsrate.
[Handeln] Aufruf search_tool("TSMC 2025 Q3 Umsatz")
[Beobachten] Suchergebnis zeigt: TSMC Q3 2025 Umsatz betrug 759,6 Mrd. TWD.
[Denken] Jetzt kann ich die Wachstumsrate berechnen: (8684 - 7596) / 7596 = 14,3%.
[Handeln] Aufruf calculator(expression="(8684 - 7596) / 7596 * 100")
[Beobachten] Berechnungsergebnis: 14,32%
[Endgueltige Antwort] Der Umsatz von TSMC im Q4 2025 betrug 868,4 Mrd. TWD, ein Anstieg von etwa 14,3% gegenueber 759,6 Mrd. TWD im Q3.

3. LangGraph im Detail: Zustandsmaschinen-Architektur auf Graph-Basis

LangGraph ist das vom LangChain-Team[10] entwickelte Agent-Orchestrierungsframework. Seine Designphilosophie basiert auf einer tiefgreifenden Erkenntnis: Der Ausfuehrungsablauf eines Agent ist im Kern ein gerichteter Graph (Directed Graph), wobei Knoten (Nodes) Berechnungsschritte und Kanten (Edges) den Kontrollfluss repraesentieren.

3.1 Kernarchitektur: StateGraph

Die zentrale Abstraktion von LangGraph ist der StateGraph -- ein gerichteter Graph mit gemeinsam genutztem Zustand im Zentrum. Jeder Knoten ist eine Funktion, die den aktuellen Zustand empfaengt, eine Berechnung durchfuehrt und eine Zustandsaktualisierung zurueckgibt. Kanten definieren die Uebergangslogik zwischen Knoten und koennen entweder unbedingt (fester Ablauf) oder bedingt (naechster Schritt abhaengig vom Zustand) sein.

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

# Gemeinsame Zustandsstruktur definieren
class AgentState(TypedDict):
    messages: Annotated[list, add]  # Nachrichten akkumulieren
    next_action: str

# Graph erstellen
graph = StateGraph(AgentState)

# Knoten hinzufuegen
graph.add_node("reason", reasoning_node)
graph.add_node("act", action_node)
graph.add_node("observe", observation_node)

# Kanten definieren (Kontrollfluss)
graph.add_edge(START, "reason")
graph.add_conditional_edges(
    "reason",
    should_continue,  # Bedingungsfunktion
    {"continue": "act", "end": END}
)
graph.add_edge("act", "observe")
graph.add_edge("observe", "reason")  # Zurueck zum Reasoning-Knoten

agent = graph.compile()

3.2 Zustandsverwaltung und Persistenz

Ein grosser Vorteil von LangGraph ist sein integrierter Zustandsverwaltungsmechanismus. Durch den Checkpointer kann der Zustand bei jedem Schritt in einer Datenbank (SQLite, PostgreSQL) persistiert werden, sodass ein Agent nach einer Unterbrechung die Ausfuehrung vom letzten Zustand wieder aufnehmen kann. Dies ist fuer lang laufende Aufgaben von entscheidender Bedeutung.

Darueber hinaus unterstuetzt LangGraph den Human-in-the-Loop-Modus: An bestimmten Knoten des Graphen koennen Haltepunkte gesetzt werden, die die Ausfuehrung pausieren und auf menschliche Ueberpruefung warten, bevor sie fortgesetzt wird. Dies ist besonders wichtig fuer Agents, die sensible Operationen durchfuehren (z.B. E-Mails versenden, Datenbanken modifizieren).

3.3 Untergraphen und Modularisierung

Komplexe Agent-Systeme koennen durch Untergraphen (Subgraphs) modularisiert werden. Beispielsweise kann ein Hauptgraph die uebergeordnete Aufgabenkoordination uebernehmen, waehrend "Datenerfassung", "Analyselogik" und "Berichterstellung" jeweils durch unabhaengige Untergraphen bearbeitet werden. Untergraphen haben ihren eigenen Zustandsraum und interagieren mit dem Hauptgraph nur ueber definierte Schnittstellen -- eine saubere Trennung der Verantwortlichkeiten.

3.4 Anwendungsszenarien

4. CrewAI im Detail: Multi-Agenten-Kollaboration durch Rollenspiel

CrewAI[11] verfolgt eine voellig andere Designphilosophie: Entwickler muessen keine Graphstruktur oder Kontrollfluesse definieren, sondern beschreiben in natuerlicher Sprache die Rolle (Role), das Ziel (Goal) und die Hintergrundgeschichte (Backstory) jedes Agent, und das Framework koordiniert automatisch die Zusammenarbeit zwischen den Agents.

4.1 Kernabstraktionen: Agent, Task, Crew

Die drei zentralen Konzepte von CrewAI sind intuitiv und elegant:

from crewai import Agent, Task, Crew, Process

# Agent definieren (Rollenspiel)
researcher = Agent(
    role="Senior-Marktforscher",
    goal="Aktuelle Marktdaten und Trends einer bestimmten Branche sammeln und verifizieren",
    backstory="Sie sind ein Marktforscher mit 15 Jahren Erfahrung, "
              "spezialisiert auf die Extraktion wichtiger Erkenntnisse aus vielfaeltigen Datenquellen.",
    tools=[search_tool, scrape_tool],
    verbose=True
)

analyst = Agent(
    role="Datenanalyse-Experte",
    goal="Die gesammelten Daten tiefgehend analysieren und verborgene Muster und Chancen identifizieren",
    backstory="Sie sind ein quantitativer Analyst mit einem Doktortitel in Statistik, "
              "spezialisiert darauf, komplexe Daten in umsetzbare Geschaeftsempfehlungen zu verwandeln.",
    tools=[calculator_tool],
    verbose=True
)

# Task definieren
research_task = Task(
    description="Untersuchen Sie die Groesse des globalen AI-Agent-Markts im Jahr 2025, "
                "die wichtigsten Akteure und Wachstumstrends.",
    expected_output="Ein strukturierter Marktforschungsbericht mit Quellenangaben.",
    agent=researcher
)

# Crew zusammenstellen
crew = Crew(
    agents=[researcher, analyst],
    tasks=[research_task, analysis_task],
    process=Process.sequential,
    verbose=True
)

4.2 Prozessmodi

CrewAI unterstuetzt zwei Hauptprozessmodi:

Der hierarchische Modus lehnt sich an die Organisationsarchitektur-Ideen von MetaGPT[6] an -- durch Rollenverteilung und hierarchisches Management wird das Verhalten mehrerer Agents koordiniert, um einem realen Teamablauf naeher zu kommen.

4.3 Integriertes Tool-Oekosystem

CrewAI bietet ein umfangreiches integriertes Tool-Kit (crewai-tools), das Websuche, Web-Scraping, PDF-Lesen, Code-Ausfuehrung und mehr umfasst. Entwickler koennen auch einfach eigene Tools erstellen, indem sie die Klasse BaseTool erweitern und die Methode _run implementieren.

4.4 Staerken und Grenzen

Staerken:

Grenzen:

5. AutoGen im Detail: Das dialoggesteuerte Multi-Agenten-Framework

AutoGen (mittlerweile umbenannt in AG2) ist ein von Microsoft Research entwickeltes Multi-Agenten-Dialogframework[5]. Im Gegensatz zur Graphstruktur von LangGraph und dem Rollenspiel-Ansatz von CrewAI lautet das zentrale Designprinzip von AutoGen: dialoggesteuert -- Agents verhandeln, debattieren, teilen Aufgaben auf und konsolidieren Ergebnisse durch mehrrundige Dialoge.

5.1 Kernkonzept: ConversableAgent

Alle Agents in AutoGen erben von ConversableAgent -- einer Entitaet, die Nachrichten empfangen, verarbeiten und beantworten kann. Die zwei am haeufigsten verwendeten Agent-Typen sind:

from autogen import AssistantAgent, UserProxyAgent, config_list_from_json

# LLM konfigurieren
config_list = [{
    "model": "gpt-4o",
    "api_key": os.environ["OPENAI_API_KEY"]
}]

# AssistantAgent erstellen
assistant = AssistantAgent(
    name="research_assistant",
    llm_config={"config_list": config_list},
    system_message="Sie sind ein professioneller KI-Forschungsassistent, "
                   "spezialisiert auf Datenrecherche, Datenanalyse und das Verfassen strukturierter Berichte."
)

# UserProxyAgent erstellen (automatische Code-Ausfuehrung)
user_proxy = UserProxyAgent(
    name="user_proxy",
    human_input_mode="NEVER",  # Vollautomatischer Modus
    code_execution_config={
        "work_dir": "workspace",
        "use_docker": False
    }
)

# Dialog starten
user_proxy.initiate_chat(
    assistant,
    message="Bitte analysieren Sie die neuesten Trends im AI-Agent-Markt "
            "und erstellen Sie mit Python ein Wachstumskurven-Diagramm."
)

5.2 Gruppenchat (GroupChat)

Eine der leistungsfaehigsten Funktionen von AutoGen ist der GroupChat -- er ermoeglicht mehreren Agents die Interaktion in einem gemeinsamen Dialograum. Der GroupChatManager entscheidet, welcher Agent in jeder Runde das Wort erhaelt -- basierend auf Regeln, Rotationsverfahren oder automatischer LLM-Auswahl.

from autogen import GroupChat, GroupChatManager

# Mehrere Agents definieren
researcher = AssistantAgent(name="researcher", ...)
coder = AssistantAgent(name="coder", ...)
critic = AssistantAgent(name="critic", ...)

# Gruppenchat zusammenstellen
groupchat = GroupChat(
    agents=[user_proxy, researcher, coder, critic],
    messages=[],
    max_round=15,
    speaker_selection_method="auto"  # LLM waehlt den Sprecher automatisch
)

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

# Multi-Agent-Dialog starten
user_proxy.initiate_chat(
    manager,
    message="Entwerfen Sie ein System zur automatischen Erfassung und Visualisierung taiwanischer Boersendaten."
)

5.3 Code-Ausfuehrung und Sandbox

Ein besonderes Merkmal von AutoGen ist die integrierte Code-Ausfuehrungsfaehigkeit. Der AssistantAgent kann Python-Code generieren, und der UserProxyAgent fuehrt diesen automatisch lokal oder in einer Docker-Sandbox aus. Bei fehlgeschlagener Ausfuehrung korrigiert der AssistantAgent den Code automatisch und versucht es erneut -- dies bildet einen automatischen Iterationszyklus aus "Generieren - Ausfuehren - Korrigieren".

5.4 Staerken und Grenzen

Staerken:

Grenzen:

6. Hands-on Lab 1: ReAct Tool-Calling Agent mit LangGraph

Diese Praxisuebung fuehrt Sie Schritt fuer Schritt durch den Aufbau eines ReAct Agent in Google Colab. Dieser Agent entscheidet eigenstaendig, wann er das Such-Tool oder den Taschenrechner aufruft, und folgt dem Zyklus "Denken - Handeln - Beobachten", bis er die endgueltige Antwort findet.

Voraussetzungen: Google Colab (kostenlose Version genuegt), ein eigener OpenAI API Key wird benoetigt.

Vollstaendiger Code -- kann direkt in Colab ausgefuehrt werden:

###############################################
# Hands-on Lab 1: LangGraph ReAct Agent
# Mit einem Klick in Colab ausfuehren
###############################################

# -- Cell 1: Pakete installieren --
# !pip install -q langgraph langchain-openai langchain-community tavily-python

# -- Cell 2: Umgebungsvariablen setzen --
import os
from getpass import getpass

# getpass fuer sichere Eingabe verwenden, wird nicht im Notebook angezeigt
if "OPENAI_API_KEY" not in os.environ:
    os.environ["OPENAI_API_KEY"] = getpass("Bitte geben Sie Ihren OpenAI API Key ein: ")

# Tavily Such-API (kostenlose Version: 1000 Abfragen/Monat)
if "TAVILY_API_KEY" not in os.environ:
    os.environ["TAVILY_API_KEY"] = getpass("Bitte geben Sie Ihren Tavily API Key ein: ")

# -- Cell 3: Tools definieren --
from langchain_community.tools.tavily_search import TavilySearchResults
from langchain_core.tools import tool

# Such-Tool
search_tool = TavilySearchResults(
    max_results=3,
    search_depth="basic",
    include_answer=True
)

# Taschenrechner-Tool
@tool
def calculator(expression: str) -> str:
    """Berechnet mathematische Ausdruecke. Die Eingabe sollte ein gueltiger Python-Rechenausdruck sein.
    Beispiel: '2 + 3 * 4' oder '100 / 7'"""
    try:
        result = eval(expression, {"__builtins__": {}}, {})
        return f"Berechnungsergebnis: {result}"
    except Exception as e:
        return f"Berechnungsfehler: {e}"

tools = [search_tool, calculator]
print(f"{len(tools)} Tools geladen: {[t.name for t in tools]}")

# -- Cell 4: ReAct Agent Graph erstellen --
from langgraph.graph import StateGraph, START, END
from langgraph.prebuilt import ToolNode
from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage, SystemMessage
from typing import TypedDict, Annotated
from operator import add

# Zustand definieren
class AgentState(TypedDict):
    messages: Annotated[list, add]

# LLM initialisieren (Tools binden)
llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)
llm_with_tools = llm.bind_tools(tools)

# System-Prompt
SYSTEM_PROMPT = """Sie sind ein professioneller Forschungsassistent. Sie koennen folgende Tools verwenden:
1. tavily_search_results_json: Suche nach aktuellen Informationen im Internet
2. calculator: Mathematische Berechnungen durchfuehren

Bitte befolgen Sie diese Regeln:
- Wenn Sie Fakteninformationen benoetigen, verwenden Sie unbedingt das Such-Tool zur Verifizierung
- Fuer numerische Berechnungen verwenden Sie den Taschenrechner fuer Genauigkeit
- Antworten Sie auf Deutsch
- Erlaeutern Sie in Ihrer endgueltigen Antwort Ihren Denkprozess"""

# Reasoning-Knoten
def reasoning_node(state: AgentState):
    messages = state["messages"]
    # System-Prompt an den Anfang setzen
    if not any(isinstance(m, SystemMessage) for m in messages):
        messages = [SystemMessage(content=SYSTEM_PROMPT)] + messages
    response = llm_with_tools.invoke(messages)
    return {"messages": [response]}

# Pruefen, ob weitere Tool-Aufrufe noetig sind
def should_continue(state: AgentState):
    last_message = state["messages"][-1]
    if hasattr(last_message, "tool_calls") and last_message.tool_calls:
        return "tools"
    return "end"

# Graph erstellen
workflow = StateGraph(AgentState)

# Knoten hinzufuegen
workflow.add_node("reason", reasoning_node)
workflow.add_node("tools", ToolNode(tools))

# Kanten definieren
workflow.add_edge(START, "reason")
workflow.add_conditional_edges(
    "reason",
    should_continue,
    {"tools": "tools", "end": END}
)
workflow.add_edge("tools", "reason")  # Tool-Ergebnisse zurueck zum Reasoning-Knoten

# Kompilieren
agent = workflow.compile()
print("ReAct Agent Graph erfolgreich kompiliert!")

# -- Cell 5: Agent-Graph-Struktur visualisieren --
from IPython.display import Image, display

try:
    display(Image(agent.get_graph().draw_mermaid_png()))
    print("Die obige Grafik zeigt die Zustandsmaschinen-Struktur des ReAct Agent:")
    print("  reason (Reasoning) -> tools (Tool-Aufruf) -> reason (erneutes Reasoning) -> ...")
except Exception:
    # Falls Mermaid-Rendering fehlschlaegt, Textversion ausgeben
    print(agent.get_graph().draw_ascii())

# -- Cell 6: Agent ausfuehren --
def run_agent(question: str):
    """Agent ausfuehren und den vollstaendigen Denkprozess ausgeben"""
    print(f"\n{'='*60}")
    print(f"Frage: {question}")
    print(f"{'='*60}\n")

    inputs = {"messages": [HumanMessage(content=question)]}

    step = 0
    for event in agent.stream(inputs, stream_mode="values"):
        last_msg = event["messages"][-1]
        step += 1

        if hasattr(last_msg, "tool_calls") and last_msg.tool_calls:
            for tc in last_msg.tool_calls:
                print(f"[Schritt {step}] Tool-Aufruf: {tc['name']}")
                print(f"  Parameter: {tc['args']}")
        elif hasattr(last_msg, "content") and last_msg.content:
            msg_type = type(last_msg).__name__
            if msg_type == "ToolMessage":
                print(f"[Schritt {step}] Tool-Rueckgabe: {last_msg.content[:200]}...")
            elif msg_type == "AIMessage":
                print(f"\n[Endgueltige Antwort]\n{last_msg.content}")

    print(f"\n{'='*60}\n")

# Testfrage 1: Frage, die eine Suche erfordert
run_agent("Wie gross war der globale KI-Markt 2025 in US-Dollar? "
          "Wenn er jaehrlich um 35% waechst, wie gross wird er 2028 sein?")

# Testfrage 2: Reine Berechnungsfrage
run_agent("Ein Unternehmen hat einen Jahresumsatz von 500 Millionen US-Dollar, "
          "eine Nettogewinnmarge von 12% und ein KGV von 25. "
          "Bitte berechnen Sie die Marktkapitalisierung.")

# -- Cell 7: Eigene Fragen --
# Sie koennen die folgende Frage aendern, um die Leistung des Agent zu testen
# run_agent("Ihre Frage")
print("Lab 1 abgeschlossen! Sie haben erfolgreich einen ReAct Tool-Calling Agent erstellt.")
print("Aendern Sie die Frage in Cell 7 und beobachten Sie, wie der Agent seine Tools auswaehlt.")

Code-Erlaeuterung:

7. Hands-on Lab 2: Multi-Agent-Forschungsteam mit CrewAI

Diese Praxisuebung baut ein Forschungsteam aus drei Agents auf: Ein Forscher sammelt Daten, ein Analyst fuehrt die Datenanalyse durch und ein Autor verfasst den Bericht. Die drei arbeiten sequenziell zusammen und erledigen automatisch eine vollstaendige Forschungsaufgabe.

Voraussetzungen: Google Colab (kostenlose Version genuegt), ein eigener OpenAI API Key wird benoetigt.

Vollstaendiger Code -- kann direkt in Colab ausgefuehrt werden:

###############################################
# Hands-on Lab 2: CrewAI Multi-Agent-Forschungsteam
# Mit einem Klick in Colab ausfuehren
###############################################

# -- Cell 1: Pakete installieren --
# !pip install -q crewai crewai-tools

# -- Cell 2: Umgebungsvariablen setzen --
import os
from getpass import getpass

if "OPENAI_API_KEY" not in os.environ:
    os.environ["OPENAI_API_KEY"] = getpass("Bitte geben Sie Ihren OpenAI API Key ein: ")

# Modell festlegen (CrewAI verwendet standardmaessig GPT-4o)
os.environ["OPENAI_MODEL_NAME"] = "gpt-4o-mini"

print("Umgebung erfolgreich konfiguriert!")

# -- Cell 3: Tools definieren --
from crewai_tools import SerperDevTool, WebsiteSearchTool
from crewai import Agent, Task, Crew, Process
from crewai_tools import tool as crewai_tool

# Einfaches Such-Tool (kein zusaetzlicher API Key erforderlich)
@crewai_tool("Web Search Tool")
def simple_search(query: str) -> str:
    """Sucht nach Informationen im Internet. Geben Sie Suchbegriffe ein, erhalten Sie eine Zusammenfassung relevanter Ergebnisse."""
    # In der Praxis wuerde hier eine echte Such-API aufgerufen
    # Fuer diese Lab-Demo verwenden wir das LLM zur Simulation von Suchergebnissen
    from langchain_openai import ChatOpenAI
    llm = ChatOpenAI(model="gpt-4o-mini", temperature=0.3)
    response = llm.invoke(
        f"Stellen Sie sich vor, Sie sind eine Suchmaschine. Liefern Sie zu folgender Anfrage "
        f"3 relevante Suchergebnis-Zusammenfassungen (mit Quellenname und Kerndaten):\n\nAnfrage: {query}"
    )
    return response.content

@crewai_tool("Calculator Tool")
def calc_tool(expression: str) -> str:
    """Berechnet mathematische Ausdruecke. Beispiel: '100 * 1.35' oder '500 / 7'"""
    try:
        result = eval(expression, {"__builtins__": {}}, {})
        return f"Berechnungsergebnis: {result}"
    except Exception as e:
        return f"Berechnungsfehler: {e}"

print("Tool-Definition abgeschlossen!")

# -- Cell 4: Drei Agents definieren --

# Agent 1: Forscher
researcher = Agent(
    role="Senior-Branchenforscher",
    goal="Neueste und zuverlaessigste Marktdaten und Branchentrends zu einem bestimmten Thema sammeln",
    backstory=(
        "Sie sind ein Branchenforscher mit 15 Jahren Erfahrung in einer fuehrenden Managementberatung. "
        "Ihre Staerke liegt darin, aus der Informationsflut die aufschlussreichsten Datenpunkte herauszufiltern "
        "und klar zwischen Primaerquellen und Sekundaerzitaten zu unterscheiden. Sie legen Wert auf Aktualitaet "
        "und bevorzugen Referenzen aus den Jahren 2024-2026."
    ),
    tools=[simple_search],
    verbose=True,
    allow_delegation=False
)

# Agent 2: Analyst
analyst = Agent(
    role="Quantitativer Analyse-Experte",
    goal="Die gesammelten Daten tiefgehend analysieren, verborgene Muster erkennen, "
         "Schluesselkennzahlen berechnen und Visualisierungsempfehlungen geben",
    backstory=(
        "Sie haben einen Doktortitel in Statistik und waren als quantitativer Forscher bei einem Hedgefonds taetig. "
        "Sie sind darauf spezialisiert, aus unstrukturierten Daten Signale zu extrahieren und koennen CAGR, "
        "Marktanteile, Wachstumsraten und andere wichtige Geschaeftskennzahlen berechnen. Ihre Analysen "
        "beinhalten stets den Rechenweg, um die Verifizierbarkeit der Schlussfolgerungen sicherzustellen."
    ),
    tools=[calc_tool, simple_search],
    verbose=True,
    allow_delegation=False
)

# Agent 3: Autor
writer = Agent(
    role="Technischer Content-Stratege",
    goal="Forschungsdaten und Analyseergebnisse in einen professionellen, gut lesbaren deutschen Bericht integrieren",
    backstory=(
        "Sie waren Senior-Redakteur bei McKinsey und sind darauf spezialisiert, komplexe technische Analysen "
        "in Strategieberichte umzuwandeln, die das Top-Management verstehen kann. Ihr Schreibstil ist "
        "praegnant und ueberzeugend, Sie nutzen geschickt Analogien und Visualisierungsvorschlaege, "
        "um Kernaussagen zu vermitteln. Ihre Berichte verfassen Sie stets auf Deutsch."
    ),
    tools=[],
    verbose=True,
    allow_delegation=False
)

print("Drei Agents definiert: Forscher, Analyst, Autor")

# -- Cell 5: Aufgaben definieren --

# Forschungsthema definieren (Sie koennen dies aendern!)
RESEARCH_TOPIC = "AI-Agent-Entwicklungsframework-Markt: Wettbewerbslandschaft und Zukunftstrends von LangGraph, CrewAI und AutoGen"

# Task 1: Marktforschung
research_task = Task(
    description=(
        f"Fuehren Sie eine umfassende Marktrecherche zum folgenden Thema durch:\n\n"
        f"Thema: {RESEARCH_TOPIC}\n\n"
        f"Sie muessen folgende Informationen recherchieren und sammeln:\n"
        f"1. GitHub-Sterne, Anzahl der Mitwirkenden, Haeufigkeit der Versionsaktualisierungen je Framework\n"
        f"2. Wichtigste Unternehmensanwender und Anwendungsfaelle je Framework\n"
        f"3. Groesse und Aktivitaet der Entwickler-Community\n"
        f"4. Finanzierungshintergrund und Kommerzialisierungsstrategie je Framework\n"
        f"5. Wichtige Updates und Roadmap fuer 2025-2026"
    ),
    expected_output=(
        "Ein strukturiertes Forschungsmemorandum mit konkreten Daten zu den oben genannten "
        "fuenf Aspekten, jeder Datenpunkt mit Quellenangabe und Datum versehen."
    ),
    agent=researcher
)

# Task 2: Datenanalyse
analysis_task = Task(
    description=(
        "Fuehren Sie basierend auf den vom Forscher bereitgestellten Daten folgende Analysen durch:\n\n"
        "1. Berechnung der jaehrlichen Wachstumsrate (CAGR) je Framework -- mit GitHub-Sternen als Proxy-Indikator\n"
        "2. Erstellung einer Funktionsvergleichsmatrix (Kontrollgranularitaet, Lernkurve, Multi-Agent-Unterstuetzung usw.)\n"
        "3. Analyse der technischen Wettbewerbsvorteile und potenziellen Risiken je Framework\n"
        "4. Prognose der Marktentwicklung fuer die naechsten 12 Monate\n"
        "5. Framework-Empfehlungen fuer verschiedene Anwendungsszenarien"
    ),
    expected_output=(
        "Ein Bericht mit quantitativen Analyseergebnissen. Einschliesslich Rechenwegen, "
        "Vergleichstabellen und datenbasierten Strategieempfehlungen."
    ),
    agent=analyst
)

# Task 3: Berichterstellung
writing_task = Task(
    description=(
        "Integrieren Sie alle Ergebnisse von Forscher und Analyst in einen vollstaendigen deutschen Analysebericht.\n\n"
        "Berichtsstruktur:\n"
        "1. Zusammenfassung (3-5 Saetze zu den Kernergebnissen)\n"
        "2. Marktueberblick (Groesse, Trends, wichtigste Akteure)\n"
        "3. Tiefgehender Framework-Vergleich (Funktionen, Leistung, Community, Kommerzialisierung)\n"
        "4. Entscheidungsempfehlungen (Framework-Empfehlung nach Anwendungsszenario)\n"
        "5. Risikohinweise und Zukunftsausblick\n\n"
        "Anforderungen: Sprache Deutsch, professioneller aber gut lesbarer Stil, "
        "Schluesseldaten fett hervorgehoben, angemessene Verwendung von Tabellen und Listen."
    ),
    expected_output=(
        "Ein professioneller deutscher Analysebericht mit 800-1200 Woertern, "
        "bestehend aus Zusammenfassung, Hauptteil, Vergleichstabelle und Strategieempfehlungen."
    ),
    agent=writer
)

print("Drei Aufgaben definiert: Recherche -> Analyse -> Berichterstellung")

# -- Cell 6: Crew zusammenstellen und ausfuehren --

crew = Crew(
    agents=[researcher, analyst, writer],
    tasks=[research_task, analysis_task, writing_task],
    process=Process.sequential,  # Sequenzielle Ausfuehrung
    verbose=True
)

print("Crew zusammengestellt! Starte Multi-Agent-Kollaboration...\n")
print("=" * 60)

# Ausfuehren!
result = crew.kickoff()

print("\n" + "=" * 60)
print("Multi-Agent-Kollaboration abgeschlossen!")
print("=" * 60)

# -- Cell 7: Abschlussbericht anzeigen --
print("\n\n" + "=" * 60)
print("Abschlussbericht")
print("=" * 60 + "\n")
print(result.raw)

# -- Cell 8: Ausfuehrungsstatistiken anzeigen --
print("\n\n" + "=" * 60)
print("Ausfuehrungsstatistiken")
print("=" * 60)

# Token-Verbrauch anzeigen
if hasattr(result, "token_usage"):
    usage = result.token_usage
    print(f"Gesamter Token-Verbrauch: {usage.total_tokens:,}")
    print(f"  - Prompt Tokens: {usage.prompt_tokens:,}")
    print(f"  - Completion Tokens: {usage.completion_tokens:,}")

# Ausgaben der einzelnen Tasks anzeigen
if hasattr(result, "tasks_output"):
    for i, task_output in enumerate(result.tasks_output):
        print(f"\nTask {i+1} ({['Recherche', 'Analyse', 'Berichterstellung'][i]}):")
        print(f"  Agent: {task_output.agent}")
        print(f"  Ausgabelaenge: {len(task_output.raw)} Zeichen")

print("\n\nLab 2 abgeschlossen!")
print("Sie koennen die Variable RESEARCH_TOPIC in Cell 5 aendern,")
print("um das Forschungsteam Berichte zu anderen Themen erstellen zu lassen.")

Code-Erlaeuterung:

Fortgeschrittene Herausforderung: Versuchen Sie, Process.sequential durch Process.hierarchical zu ersetzen und beobachten Sie, wie das Framework automatisch einen "Manager-Agent" zur Koordination der Aufgabenverteilung einfuehrt.

8. Entscheidungsframework: Vergleich und Auswahlleitfaden der drei Frameworks

Nach der eingehenden Analyse und den praktischen Uebungen koennen wir nun die drei Frameworks systematisch vergleichen und Ihnen bei der Auswahl der optimalen Loesung fuer Ihre spezifischen Anforderungen helfen.

8.1 Umfassende Vergleichstabelle

Vergleichsdimension LangGraph CrewAI AutoGen (AG2)
Kernabstraktion Gerichteter Graph (StateGraph) Agent + Task + Crew ConversableAgent + GroupChat
Designphilosophie Zustandsmaschine, Graph-Computing Rollenspiel, Aufgabendelegation Dialoggesteuert, multilaterale Verhandlung
Kontrollgranularitaet Sehr hoch -- jede Kante und Bedingung definierbar Niedrig -- Framework koordiniert automatisch Mittel -- konfigurierbar, aber weniger intuitiv als Graphen
Lernkurve Mittel -- erfordert Verstaendnis von Graph- und Zustandskonzepten Niedrig -- intuitive Rollendefinition Hoch -- viele Konzeptebenen, komplexe API
Multi-Agent-Unterstuetzung Ueber Untergraphen Native Unterstuetzung (Crew) Native Unterstuetzung (GroupChat)
Zustandsverwaltung Integrierter Checkpointer mit Persistenz Grundlegende Kontext-Weitergabe Automatische Verwaltung der Dialoghistorie
Human-in-the-Loop Native Unterstuetzung fuer Haltepunkte und menschliche Ueberpruefung Eingeschraenkte Unterstuetzung Unterstuetzt (human_input_mode)
Code-Ausfuehrung Erfordert eigene Integration Ueber Tools unterstuetzt Nativ integriert (Docker-Sandbox)
Observability Hervorragend -- LangSmith-Integration Grundlegendes Verbose-Logging Mittel -- Dialog-Logging
Oekosystem LangChain-Oekosystem (am umfangreichsten) Eigenstaendig, aber schnell wachsend Microsoft-Oekosystem
Geeignet fuer Erfahrene Backend-Entwickler Teams fuer schnelles Prototyping Forschungsorientierte Teams
Produktionsreife Hoch Mittel Mittel
Lizenz MIT MIT Apache 2.0 (urspr.) / CC BY 4.0 (AG2)

8.2 Szenariobasierter Auswahlleitfaden

Basierend auf Ihrem spezifischen Anwendungsszenario empfehlen wir folgende Auswahlstrategie:

Waehlen Sie LangGraph, wenn Sie:

Waehlen Sie CrewAI, wenn Sie:

Waehlen Sie AutoGen (AG2), wenn Sie:

8.3 Hybride Nutzungsstrategie

In der Unternehmenspraxis empfehlen wir unseren Kunden haeufig eine hybride Strategie: CrewAI fuer die schnelle Konzeptvalidierung (in der Phase des AI PoC (Proof of Concept)) verwenden, und nach Bestaetigung der Machbarkeit mit LangGraph zu einem produktionsreifen System umschreiben. Fuer Submodule, die Code-Generierung und -Ausfuehrung erfordern, kann die Code-Ausfuehrungsfaehigkeit von AutoGen eingebettet werden. Diese Strategie vereint Entwicklungsgeschwindigkeit mit Produktionsstabilitaet.

Die Erkenntnisse von Xie et al. im TravelPlanner-Benchmark[12] stuetzen diese Sichtweise ebenfalls: Es ist unrealistisch, dass ein einzelnes Framework in allen Szenarien am besten abschneidet. Die Auswahl der am besten geeigneten Tool-Kombination fuer unterschiedliche Aufgabencharakteristiken ist die ingenieurtechnisch optimale Loesung.

9. Fazit und Ausblick

Die Entwicklung von AI Agents befindet sich an einem spannenden Wendepunkt. Von einzelnen ReAct-Zyklen bis hin zu Multi-Agenten-Kollaborationssystemen, von einfachen Tool-Aufrufen bis zu komplexer Aufgabenplanung und Selbstreflexion -- die Faehigkeitsgrenzen von Agents erweitern sich mit erstaunlicher Geschwindigkeit.

Dennoch muessen wir die aktuellen Herausforderungen klar benennen:

Mit Blick auf die Zukunft sehen wir mehrere wichtige konvergierende Trends:

Erstens: Die Standardisierung des MCP-Protokolls (Model Context Protocol)[15]. Das von Anthropic vorgeschlagene MCP-Protokoll entwickelt sich zum universellen Standard fuer die Interaktion zwischen Agents und externen Tools. Dies wird die Integrationskosten erheblich senken und die Interoperabilitaet des Agent-Oekosystems foerdern.

Zweitens: Agent-native Foundation Models. Zukuenftige LLMs werden keine Sprachmodelle mehr sein, denen Agent-Funktionalitaet nachtraeglich hinzugefuegt wird, sondern bereits ab der Pretraining-Phase fuer Agent-Szenarien optimiert -- mit besserer Tool-Calling-Genauigkeit, staerkerer mehrstufiger Planungsfaehigkeit und niedrigerer Halluzinationsrate.

Drittens: Konvergenz und Standardisierung der Frameworks. Derzeit hat jedes der drei Frameworks seine Staerken, ist aber untereinander inkompatibel. In Zukunft koennten hoehere Abstraktionsebenen entstehen, die es Entwicklern ermoeglichen, die Vorteile verschiedener Frameworks ueber eine einheitliche Schnittstelle zu nutzen.

Fuer Unternehmen ist jetzt der ideale Zeitpunkt, sich strategisch mit Agent-Technologie zu positionieren. Sie muessen nicht auf das "perfekte" Framework warten -- waehlen Sie ein Tool, das Ihren aktuellen Anforderungen entspricht, beginnen Sie mit dem Aufbau und sammeln Sie in der Praxis Erfahrung und Datensaetze. Unsere Erfahrung bei Meta Intelligence zeigt: Die erfolgreichsten Agent-Projekte entstehen nicht auf einen Schlag, sondern beginnen mit einfachen ReAct Tool-Aufrufen, werden schrittweise auf Multi-Agenten-Kollaboration erweitert und validieren bei jedem Schritt den Geschaeftswert.

Wenn Ihr Team die Einfuehrung von AI Agents evaluiert oder bei der Framework-Auswahl auf Schwierigkeiten stoesst, nehmen Sie gerne Kontakt mit uns auf. Unser Forschungsteam verfolgt kontinuierlich die neuesten Entwicklungen in der Agent-Technologie und kann Sie bei jedem Schritt unterstuetzen -- von der Architekturplanung ueber die Framework-Auswahl bis hin zum Produktivbetrieb.