Nutzung#

AutoGen Studio (AGS) bietet eine Team-Builder-Oberfläche, auf der Entwickler mehrere Komponenten und Verhaltensweisen definieren können. Benutzer können Teams erstellen, Agenten zu Teams hinzufügen, Werkzeuge und Modelle an Agenten anhängen und Team-Abbruchbedingungen definieren. Nach der Definition eines Teams können Benutzer direkt in der Team-Builder-Ansicht testen oder es an eine Sitzung anhängen, um es in der Playground-Ansicht zu verwenden.

Siehe ein Video-Tutorial zu AutoGen Studio v0.4 (25.02.) - https://youtu.be/oum6EI7wohM

A Friendly Introduction to AutoGen Studio v0.4

API-Schlüssel einrichten#

Die meisten Ihrer Agenten benötigen einen API-Schlüssel. Sie können eine Umgebungsvariable OPENAI_API_KEY einrichten (vorausgesetzt, Sie verwenden OpenAI-Modelle), und AutoGen wird diese automatisch für alle OpenAI-Modell-Clients verwenden, die Sie für Ihre Agenten oder Teams angeben. Alternativ können Sie den API-Schlüssel als Teil der Team- oder Agentenkonfiguration angeben.

Siehe den folgenden Abschnitt, wie Sie ein Agenten-Team entweder mit dem visuellen Builder oder durch direkte Bearbeitung der JSON-Konfiguration erstellen.

Agenten-Team erstellen#


AutoGen Studio integriert sich eng mit allen Komponentenabstraktionen, die von AutoGen AgentChat bereitgestellt werden, einschließlich teams, agents, models, tools und Abbruch-conditions.

Die Team-Builder-Ansicht in AGS bietet einen visuellen Team-Builder, der es Benutzern ermöglicht, Komponenten entweder per Drag-and-Drop oder durch direkte Bearbeitung einer JSON-Konfiguration des Teams zu definieren.

Visuellen Builder verwenden#

Der visuelle Builder ist standardmäßig aktiviert und ermöglicht es Benutzern, Komponenten aus der bereitgestellten Komponentenbibliothek auf die Team-Builder-Leinwand zu ziehen. Die Team-Builder-Leinwand repräsentiert ein Team und besteht aus einem Haupt-Team-Knoten und einer Reihe von verbundenen Agenten-Knoten. Sie enthält eine Komponentenbibliothek mit einer Auswahl von Komponenten, die zu den Team- oder Agenten-Knoten auf der Leinwand hinzugefügt werden können.

Team Builder

Die wichtigsten unterstützten Verhaltensweisen umfassen

  • Ein neues Team erstellen. Dies kann durch Klicken auf die Schaltfläche "Neues Team" in der Team-Builder-Ansicht oder durch Auswahl eines der vorhandenen Standardteams, die mit der Standard-AGS-Galerie geliefert werden, erfolgen. Sobald Sie dies tun, werden ein neuer Team-Knoten und ein oder mehrere Agenten-Knoten auf der Leinwand erstellt.

  • Komponenten per Drag-and-Drop von der Bibliothek zu den Team- oder Agenten-Knoten auf der Leinwand ziehen.

    • Teams: Agenten und Abbruchbedingungen zum Team-Knoten ziehen (es gibt spezifische Drop-Zonen für diese Komponenten)

    • Agenten: Modelle und Werkzeuge zum Agenten-Knoten ziehen (es gibt spezifische Drop-Zonen für diese Komponenten)

  • Team/Agenten-Knoten bearbeiten: Klicken Sie auf das Bearbeiten-Symbol (oben rechts) des Knotens, um seine Eigenschaften anzuzeigen und zu bearbeiten. Dies öffnet ein Fenster, in dem Sie die Felder des Knotens bearbeiten können. In einigen Fällen müssen Sie nach unten scrollen und in bestimmte Abschnitte klicken, z. B. für einen Agenten mit einem Modell-Client müssen Sie in den Modell-Client-Abschnitt klicken, um die Eigenschaften des Modell-Clients zu bearbeiten. Sobald Sie mit der Bearbeitung fertig sind, klicken Sie auf die Schaltfläche "Speichern", um die Änderungen zu speichern.

JSON-Editor verwenden#

JSON Editor

AGS ermöglicht es Ihnen auch, die JSON-Konfiguration des Teams direkt zu ändern. Dies kann geschehen, indem Sie den visuellen Builder-Modus deaktivieren. Sobald Sie dies tun, sehen Sie die JSON-Konfiguration des Teams. Sie können dann die JSON-Konfiguration direkt bearbeiten.

Wussten Sie schon, dass Sie Ihre Agenten in Python definieren, sie nach JSON exportieren und dann in den JSON-Editor einfügen können? Der folgende Abschnitt zeigt, wie das geht.

Deklarative Spezifikation von Komponenten#

AutoGen Studio basiert auf den deklarativen Spezifikationsverhaltensweisen von AutoGen AgentChat. Dies ermöglicht es Benutzern, Teams, Agenten, Modelle, Werkzeuge und Abbruchbedingungen in Python zu definieren und sie dann in eine JSON-Datei für die Verwendung in AutoGen Studio zu exportieren.

Hier ist ein Beispiel für ein Agenten-Team und wie es in eine JSON-Datei konvertiert wird

from autogen_agentchat.agents import AssistantAgent
from autogen_agentchat.teams import RoundRobinGroupChat
from autogen_ext.models.openai import OpenAIChatCompletionClient
from autogen_agentchat.conditions import  TextMentionTermination

agent = AssistantAgent(
        name="weather_agent",
        model_client=OpenAIChatCompletionClient(
            model="gpt-4o-mini",
        ),
    )

agent_team = RoundRobinGroupChat([agent], termination_condition=TextMentionTermination("TERMINATE"))
config = agent_team.dump_component()
print(config.model_dump_json())

{
  "provider": "autogen_agentchat.teams.RoundRobinGroupChat",
  "component_type": "team",
  "version": 1,
  "component_version": 1,
  "description": "A team that runs a group chat with participants taking turns in a round-robin fashion\n    to publish a message to all.",
  "label": "RoundRobinGroupChat",
  "config": {
    "participants": [
      {
        "provider": "autogen_agentchat.agents.AssistantAgent",
        "component_type": "agent",
        "version": 1,
        "component_version": 1,
        "description": "An agent that provides assistance with tool use.",
        "label": "AssistantAgent",
        "config": {
          "name": "weather_agent",
          "model_client": {
            "provider": "autogen_ext.models.openai.OpenAIChatCompletionClient",
            "component_type": "model",
            "version": 1,
            "component_version": 1,
            "description": "Chat completion client for OpenAI hosted models.",
            "label": "OpenAIChatCompletionClient",
            "config": { "model": "gpt-4o-mini" }
          },
          "tools": [],
          "handoffs": [],
          "model_context": {
            "provider": "autogen_core.model_context.UnboundedChatCompletionContext",
            "component_type": "chat_completion_context",
            "version": 1,
            "component_version": 1,
            "description": "An unbounded chat completion context that keeps a view of the all the messages.",
            "label": "UnboundedChatCompletionContext",
            "config": {}
          },
          "description": "An agent that provides assistance with ability to use tools.",
          "system_message": "You are a helpful AI assistant. Solve tasks using your tools. Reply with TERMINATE when the task has been completed.",
          "model_client_stream": false,
          "reflect_on_tool_use": false,
          "tool_call_summary_format": "{result}"
        }
      }
    ],
    "termination_condition": {
      "provider": "autogen_agentchat.conditions.TextMentionTermination",
      "component_type": "termination",
      "version": 1,
      "component_version": 1,
      "description": "Terminate the conversation if a specific text is mentioned.",
      "label": "TextMentionTermination",
      "config": { "text": "TERMINATE" }
    }
  }
}

Dieses Beispiel zeigt ein Team mit einem einzelnen Agenten, der den RoundRobinGroupChat Typ und eine TextMentionTermination Bedingung verwendet. Sie werden auch feststellen, dass der Modell-Client ein OpenAIChatCompletionClient Modell-Client ist, bei dem nur der Modellname angegeben ist. In diesem Fall wird angenommen, dass der API-Schlüssel als Umgebungsvariable OPENAI_API_KEY gesetzt ist. Sie können den API-Schlüssel auch als Teil der Modell-Client-Konfiguration angeben.

Um die vollständige Konfiguration von Modell-Clients zu verstehen, können Sie die AutoGen Model Clients Dokumentation konsultieren.

Beachten Sie, dass Sie Ihren Modell-Client ähnlich in Python definieren und dump_component() darauf aufrufen können, um die JSON-Konfiguration zu erhalten und sie zur Aktualisierung des Modell-Client-Abschnitts Ihrer Team- oder Agentenkonfiguration zu verwenden.

Schließlich können Sie die Methode load_component() verwenden, um eine Teamkonfiguration aus einer JSON-Datei zu laden


import json
from autogen_agentchat.teams import BaseGroupChat
team_config = json.load(open("team.json"))
team = BaseGroupChat.load_component(team_config)

Teams interaktiv ausführen#

Der AutoGen Studio Playground ermöglicht es Benutzern,

  • Teams für spezifische Aufgaben testen

  • Generierte Artefakte (Bilder, Code, Text) überprüfen

  • Den "inneren Monolog" des Teams während der Aufgabenausführung überwachen

  • Leistungsmetriken anzeigen (Zugriffszahl, Token-Verbrauch)

  • Agentenaktionen verfolgen (Werkzeugnutzung, Codeausführungsergebnisse)

Teamkonfigurationen importieren und wiederverwenden#

Die Galerie-Ansicht von AutoGen Studio bietet eine Standard-Komponentensammlung und unterstützt den Import externer Konfigurationen

  • Erstellen/Importieren von Galerien über Galerie -> Neue Galerie -> Import

  • Festlegen von Standardgalerien über das Pin-Symbol in der Seitenleiste

  • Zugriff auf Komponenten im Team-Builder über Seitenleiste -> Aus Galerie

Python-Integration#

Teamkonfigurationen können in Python-Anwendungen mit der TeamManager-Klasse integriert werden

from autogenstudio.teammanager import TeamManager

tm = TeamManager()
result_stream = tm.run(task="What is the weather in New York?", team_config="team.json") # or tm.run_stream(..)

Um Teamkonfigurationen zu exportieren, verwenden Sie die Export-Schaltfläche im Team-Builder, um eine JSON-Datei für die Verwendung in Python-Anwendungen zu generieren.