OpenAI Swarm - Detaillierte Einführung in das Multi-Agenten-Orchestrierungs-Framework
Projektübersicht
OpenAI Swarm ist ein pädagogisches Framework zur Erforschung ergonomischer, leichtgewichtiger Multi-Agenten-Orchestrierung. Das Projekt wird vom OpenAI-Lösungsteam verwaltet und zielt darauf ab, Entwicklern ein einfaches, flexibles und steuerbares Tool zum Aufbau von Multi-Agenten-Systemen bereitzustellen.
Wichtige Aktualisierung: Swarm wurde durch das OpenAI Agents SDK ersetzt, die produktionsreife Version von Swarm. Das OpenAI-Team empfiehlt, alle Produktionsanwendungen zum Agents SDK zu migrieren.
Kernfunktionen
1. Designprinzipien
- Leichtgewichtig: Fokus auf Einfachheit und Benutzerfreundlichkeit
- Hochgradig steuerbar: Bietet präzise Agenten-Steuerungsmechanismen
- Einfach zu testen: Unterstützt einfache Test- und Debugging-Prozesse
- Bildungsorientiert: Als Bildungsressource zum Erlernen der Multi-Agenten-Orchestrierung
2. Kernabstraktionen
Swarm realisiert die Agenten-Koordination durch zwei Kernabstraktionen:
Agent (Intelligenter Agent)
- Enthält Anweisungen (instructions) und Werkzeuge (tools)
- Kann die Konversation jederzeit an einen anderen Agenten übergeben
- Unterstützt dynamische Anweisungen und Kontextvariablen
Handoffs (Übergaben)
- Nahtloser Übergangsmechanismus zwischen Agenten
- Unterstützt komplexe Agenten-Netzwerke und Workflows
- Bewahrt die Kontinuität der Konversation
Installation und grundlegende Verwendung
Systemanforderungen
- Python 3.10+
Installationsmethode
pip install git+ssh://[email protected]/openai/swarm.git
# Oder
pip install git+https://github.com/openai/swarm.git
Grundlegendes Beispiel
from swarm import Swarm, Agent
client = Swarm()
def transfer_to_agent_b():
return agent_b
agent_a = Agent(
name="Agent A",
instructions="You are a helpful agent.",
functions=[transfer_to_agent_b],
)
agent_b = Agent(
name="Agent B",
instructions="Only speak in Haikus.",
)
response = client.run(
agent=agent_a,
messages=[{"role": "user", "content": "I want to talk to agent B."}],
)
print(response.messages[-1]["content"])
Beispielausgabe:
Hope glimmers brightly,
New paths converge gracefully,
What can I assist?
Technische Architektur
Client-Ausführungsmechanismus
Die client.run()-Funktion von Swarm implementiert die folgende Schleife:
- Abrufen einer vollständigen Antwort vom aktuellen Agenten
- Ausführen von Werkzeugaufrufen und Hinzufügen der Ergebnisse
- Bei Bedarf Wechsel des Agenten
- Aktualisieren der Kontextvariablen
- Wenn keine neuen Funktionsaufrufe vorhanden sind, Rückgabe des Ergebnisses
Parameterkonfiguration
| Parameter | Typ | Beschreibung | Standardwert |
|---|---|---|---|
| agent | Agent | Der aufzurufende (initiale) Agent | (Erforderlich) |
| messages | List | Liste der Nachrichtenobjekte | (Erforderlich) |
| context_variables | dict | Kontextvariablen | {} |
| max_turns | int | Maximale Anzahl von Durchläufen | float("inf") |
| model_override | str | Modellüberschreibung | None |
| execute_tools | bool | Ob Werkzeuge ausgeführt werden sollen | True |
| stream | bool | Ob Streaming-Antworten aktiviert werden sollen | False |
| debug | bool | Ob Debug-Protokollierung aktiviert werden soll | False |
Agentenkonfiguration
Agent-Klassenfelder
| Feld | Typ | Beschreibung | Standardwert |
|---|---|---|---|
| name | str | Agentenname | "Agent" |
| model | str | Verwendetes Modell | "gpt-4o" |
| instructions | str oder Funktion | Agentenanweisungen | "You are a helpful agent." |
| functions | List | Liste der aufrufbaren Funktionen | [] |
| tool_choice | str | Werkzeugauswahlstrategie | None |
Beispiel für dynamische Anweisungen
def instructions(context_variables):
user_name = context_variables["user_name"]
return f"Help the user, {user_name}, do whatever they want."
agent = Agent(instructions=instructions)
response = client.run(
agent=agent,
messages=[{"role":"user", "content": "Hi!"}],
context_variables={"user_name":"John"}
)
Funktionsaufrufmechanismus
Grundlegender Funktionsaufruf
def greet(context_variables, language):
user_name = context_variables["user_name"]
greeting = "Hola" if language.lower() == "spanish" else "Hello"
print(f"{greeting}, {user_name}!")
return "Done"
agent = Agent(functions=[greet])
Agentenübergabe
sales_agent = Agent(name="Sales Agent")
def transfer_to_sales():
return sales_agent
agent = Agent(functions=[transfer_to_sales])
Komplexe Ergebniszurückgabe
def talk_to_sales():
print("Hello, World!")
return Result(
value="Done",
agent=sales_agent,
context_variables={"department": "sales"}
)
Beispielprojekte
Swarm bietet mehrere Beispielprojekte, die verschiedene Anwendungsszenarien demonstrieren:
1. basic - Grundlegendes Beispiel
Demonstriert die grundlegende Verwendung von Einrichtung, Funktionsaufrufen, Übergaben und Kontextvariablen
2. triage_agent - Triage-Agent
Einfache Triage-Einrichtung, die Anfragen an den entsprechenden Agenten weiterleitet
3. weather_agent - Wetter-Agent
Einfaches Beispiel zur Demonstration von Funktionsaufrufen
4. airline - Fluggesellschaft-Kundenservice
Multi-Agenten-Einrichtung zur Bearbeitung verschiedener Arten von Kundenserviceanfragen für Fluggesellschaften
5. support_bot - Support-Bot
Beinhaltet einen Benutzeroberflächen-Agenten und einen Hilfezentrum-Agenten mit verschiedenen Werkzeugen
6. personal_shopper - Persönlicher Einkaufsassistent
Persönlicher Einkaufsagent, der bei der Bearbeitung von Verkaufs- und Rückerstattungsbestellungen hilft
Streaming-Verarbeitung
Swarm unterstützt Streaming-Antworten und verwendet die gleichen Ereignisse wie die Chat Completions API:
stream = client.run(agent, messages, stream=True)
for chunk in stream:
print(chunk)
Neue Ereignistypen:
{"delim":"start"}und{"delim":"end"}- Markieren den Beginn und das Ende der Verarbeitung einer einzelnen Nachricht durch den Agenten{"response": Response}- Gibt das vollständige Response-Objekt am Ende des Streams zurück
Testen und Evaluieren
Entwicklungstests
Verwenden Sie run_demo_loop für Befehlszeilentests:
from swarm.repl import run_demo_loop
run_demo_loop(agent, stream=True)
Bewertungsempfehlungen
- Das Projekt ermutigt Entwickler, eigene Bewertungssuiten mitzubringen
- In den Beispielen airline, weather_agent und triage_agent werden Bewertungsreferenzen bereitgestellt
- Unterstützung für benutzerdefinierte Leistungstestmetriken
Unterschiede zu anderen OpenAI-Produkten
Vergleich mit der Assistants API
- Assistants API: Bietet vollständig verwaltete Threads und integriertes Speichermanagement
- Swarm: Läuft vollständig auf dem Client, zustandsloses Design, besser geeignet zum Lernen und Experimentieren
Technische Merkmale
- Basiert auf der Chat Completions API
- Speichert keinen Zustand zwischen Aufrufen
- Leichtgewichtige Client-Implementierung
- Konzentriert sich auf Bildungs- und Lernzwecke
Anwendungsfälle
Swarm eignet sich besonders für folgende Situationen:
- Szenarien, die die Verarbeitung einer großen Anzahl unabhängiger Funktionen und Anweisungen erfordern
- Komplexe Aufgaben, die sich nur schwer in eine einzelne Eingabeaufforderung codieren lassen
- Erlernen von Multi-Agenten-Orchestrierungskonzepten
- Schnelle Prototypenentwicklung und Experimente
Projektstatus
Hinweis: Obwohl Swarm durch das OpenAI Agents SDK ersetzt wurde, ist es weiterhin eine ausgezeichnete Bildungsressource, die Entwicklern hilft, die grundlegenden Konzepte und Implementierungen von Multi-Agenten-Systemen zu verstehen. Für Produktionsumgebungen wird empfohlen, zum offiziellen Agents SDK zu migrieren.
Zusammenfassung
OpenAI Swarm bietet ein einfaches und leistungsstarkes Framework zum Erlernen und Entwickeln von Multi-Agenten-Systemen. Durch die beiden Kernkonzepte Agent und Übergabe können Entwickler komplexe KI-Workflows erstellen und gleichzeitig die Lesbarkeit und Wartbarkeit des Codes gewährleisten. Obwohl es durch ein neues SDK ersetzt wurde, sind seine Designprinzipien und sein Bildungswert weiterhin wichtig.