autogen_agentchat.agents

Dieses Modul initialisiert verschiedene vordefinierte Agenten, die vom Paket bereitgestellt werden. BaseChatAgent ist die Basisklasse für alle Agenten in AgentChat.

class BaseChatAgent(name: str, description: str)

Bases: ChatAgent, ABC, ComponentBase[BaseModel]

Basisklasse für einen Chat-Agenten.

Diese abstrakte Klasse bietet eine Basisimplementierung für einen ChatAgent. Um einen neuen Chat-Agenten zu erstellen, leiten Sie diese Klasse ab und implementieren Sie die Methoden on_messages(), on_reset() und das Attribut produced_message_types. Wenn Streaming erforderlich ist, implementieren Sie auch die Methode on_messages_stream().

Ein Agent wird als zustandsbehaftet betrachtet und behält seinen Zustand zwischen den Aufrufen der Methoden on_messages() oder on_messages_stream(). Der Agent sollte seinen Zustand in der Agenteninstanz speichern. Der Agent sollte auch die Methode on_reset() implementieren, um den Agenten in seinen Initialisierungszustand zurückzusetzen.

Hinweis

Der Aufrufer sollte dem Agenten bei jedem Aufruf der Methode on_messages() oder on_messages_stream() nur die neuen Nachrichten übergeben. Übergeben Sie nicht die gesamte Konversationshistorie bei jedem Aufruf an den Agenten. Dieses Designprinzip muss beim Erstellen eines neuen Agenten beachtet werden.

component_type: ClassVar[ComponentType] = 'agent'

Der logische Typ der Komponente.

property name: str

Der Name des Agenten. Dieser wird vom Team verwendet, um den Agenten eindeutig zu identifizieren. Er sollte innerhalb des Teams eindeutig sein.

property description: str

Die Beschreibung des Agenten. Diese wird vom Team verwendet, um Entscheidungen darüber zu treffen, welche Agenten verwendet werden sollen. Die Beschreibung sollte die Fähigkeiten des Agenten und die Art und Weise, wie mit ihm interagiert werden kann, beschreiben.

abstract property produced_message_types: Sequence[type[BaseChatMessage]]

Die Arten von Nachrichten, die der Agent im Feld Response.chat_message produziert. Sie müssen BaseChatMessage-Typen sein.

abstract async on_messages(messages: Sequence[BaseChatMessage], cancellation_token: CancellationToken) → Response

Verarbeitet eingehende Nachrichten und gibt eine Antwort zurück.

Hinweis

Agenten sind zustandsbehaftet, und die an diese Methode übergebenen Nachrichten sollten die neuen Nachrichten seit dem letzten Aufruf dieser Methode sein. Der Agent sollte seinen Zustand zwischen den Aufrufen dieser Methode beibehalten. Wenn der Agent sich beispielsweise die vorherigen Nachrichten merken muss, um auf die aktuelle Nachricht zu reagieren, sollte er die vorherigen Nachrichten im Agentenzustand speichern.

async on_messages_stream(messages: Sequence[BaseChatMessage], cancellation_token: CancellationToken) → AsyncGenerator[BaseAgentEvent | BaseChatMessage | Response, None]

Verarbeitet eingehende Nachrichten und gibt einen Strom von Nachrichten zurück, wobei das letzte Element die Antwort ist. Die Basisimplementierung in BaseChatAgent ruft einfach on_messages() auf und gibt die Nachrichten in der Antwort aus.

Hinweis

Agenten sind zustandsbehaftet, und die an diese Methode übergebenen Nachrichten sollten die neuen Nachrichten seit dem letzten Aufruf dieser Methode sein. Der Agent sollte seinen Zustand zwischen den Aufrufen dieser Methode beibehalten. Wenn der Agent sich beispielsweise die vorherigen Nachrichten merken muss, um auf die aktuelle Nachricht zu reagieren, sollte er die vorherigen Nachrichten im Agentenzustand speichern.

async run(*, task: str | BaseChatMessage | Sequence[BaseChatMessage] | None = None, cancellation_token: CancellationToken | None = None, output_task_messages: bool = True) → TaskResult

Führt den Agenten mit der gegebenen Aufgabe aus und gibt das Ergebnis zurück.

async run_stream(*, task: str | BaseChatMessage | Sequence[BaseChatMessage] | None = None, cancellation_token: CancellationToken | None = None, output_task_messages: bool = True) → AsyncGenerator[BaseAgentEvent | BaseChatMessage | TaskResult, None]

Führt den Agenten mit der gegebenen Aufgabe aus und gibt einen Strom von Nachrichten sowie das finale Aufgabenergebnis als letztes Element des Stroms zurück.

Parameter:

• task – Die auszuführende Aufgabe. Kann ein String, eine einzelne Nachricht oder eine Sequenz von Nachrichten sein.

• cancellation_token – Das Abbruch-Token, um die Aufgabe sofort zu beenden.

• output_task_messages – Ob Aufgabenmeldungen in den Ausgabestrom aufgenommen werden sollen. Standardmäßig True aus Gründen der Abwärtskompatibilität.

abstract async on_reset(cancellation_token: CancellationToken) → None

Setzt den Agenten in seinen Initialzustand zurück.

async on_pause(cancellation_token: CancellationToken) → None

Wird aufgerufen, wenn der Agent während der Ausführung in seiner Methode on_messages() oder on_messages_stream() pausiert wird. Dies ist in der Klasse BaseChatAgent standardmäßig eine No-Op. Unterklassen können diese Methode überschreiben, um ein benutzerdefiniertes Pausenverhalten zu implementieren.

async on_resume(cancellation_token: CancellationToken) → None

Wird aufgerufen, wenn der Agent aus einer Pause fortgesetzt wird, während er in seiner Methode on_messages() oder on_messages_stream() läuft. Dies ist in der Klasse BaseChatAgent standardmäßig eine No-Op. Unterklassen können diese Methode überschreiben, um ein benutzerdefiniertes Fortsetzungsverhalten zu implementieren.

async save_state() → Mapping[str, Any]

Zustand exportieren. Standardimplementierung für zustandslose Agenten.

async load_state(state: Mapping[str, Any]) → None

Agent aus gespeichertem Zustand wiederherstellen. Standardimplementierung für zustandslose Agenten.

async close() → None

Ressourcen freigeben, die vom Agenten gehalten werden. Dies ist in der Klasse BaseChatAgent standardmäßig eine No-Op. Unterklassen können diese Methode überschreiben, um ein benutzerdefiniertes Schließungsverhalten zu implementieren.

class AssistantAgent(name: str, model_client: ChatCompletionClient, *, tools: List[BaseTool[Any, Any] | Callable[[...], Any] | Callable[[...], Awaitable[Any]]] | None = None, workbench: Workbench | Sequence[Workbench] | None = None, handoffs: List[Handoff | str] | None = None, model_context: ChatCompletionContext | None = None, description: str = 'Ein Agent, der Hilfe bei der Werkzeugnutzung bietet.', system_message: str | None = 'Sie sind ein hilfsbereiter KI-Assistent. Lösen Sie Aufgaben mit Ihren Werkzeugen. Antworten Sie mit TERMINATE, wenn die Aufgabe abgeschlossen ist.', model_client_stream: bool = False, reflect_on_tool_use: bool | None = None, max_tool_iterations: int = 1, tool_call_summary_format: str = '{result}', tool_call_summary_formatter: Callable[[FunctionCall, FunctionExecutionResult], str] | None = None, output_content_type: type[BaseModel] | None = None, output_content_type_format: str | None = None, memory: Sequence[Memory] | None = None, metadata: Dict[str, str] | None = None)

Bases: BaseChatAgent, Component[AssistantAgentConfig]

Ein Agent, der Hilfe bei der Werkzeugnutzung leistet. Die Methode on_messages() gibt eine Response zurück, bei der chat_message die endgültige Antwortnachricht ist.

Die Methode on_messages_stream() erstellt einen asynchronen Generator, der die inneren Nachrichten erzeugt, sobald sie erstellt werden, und das Response-Objekt als letztes Element vor dem Schließen des Generators liefert.

Die Methode BaseChatAgent.run() gibt ein TaskResult mit den vom Agenten erzeugten Nachrichten zurück. In der Liste der Nachrichten, messages, ist die letzte Nachricht die endgültige Antwortnachricht.

Die Methode BaseChatAgent.run_stream() erstellt einen asynchronen Generator, der die inneren Nachrichten erzeugt, sobald sie erstellt werden, und das TaskResult-Objekt als letztes Element vor dem Schließen des Generators liefert.

Achtung

Der Aufrufer muss dem Agenten bei jedem Aufruf der Methoden on_messages(), on_messages_stream(), BaseChatAgent.run() oder BaseChatAgent.run_stream() nur die neuen Nachrichten übergeben. Der Agent behält seinen Zustand zwischen den Aufrufen dieser Methoden bei. Übergeben Sie nicht die gesamte Konversationshistorie bei jedem Aufruf an den Agenten.

Warnung

Der Assistenten-Agent ist nicht thread-sicher oder koroutinen-sicher. Er sollte nicht zwischen mehreren Aufgaben oder Koroutinen geteilt werden, und seine Methoden sollten nicht gleichzeitig aufgerufen werden.

Das folgende Diagramm zeigt, wie der Assistenten-Agent funktioniert.

Strukturierte Ausgabe

Wenn output_content_type gesetzt ist, antwortet der Agent standardmäßig mit einer StructuredMessage anstelle einer TextMessage in der endgültigen Antwort.

Hinweis

Derzeit verhindert die Einstellung von output_content_type, dass der Agent die Methoden load_component und dum_component für serialisierbare Konfigurationen aufrufen kann. Dies wird in Kürze behoben.

Verhalten bei Werkzeugaufrufen

• Wenn das Modell keinen Werkzeugaufruf zurückgibt, wird die Antwort sofort als TextMessage oder als StructuredMessage (bei Verwendung von strukturierter Ausgabe) in chat_message zurückgegeben. Dies beendet die Werkzeugaufruf-Iterationsschleife unabhängig von der Einstellung max_tool_iterations.

• Wenn das Modell Werkzeugaufrufe zurückgibt, werden diese sofort ausgeführt.

  • Wenn reflect_on_tool_use auf `False` gesetzt ist, werden die Ergebnisse der Werkzeugaufrufe als ToolCallSummaryMessage in chat_message zurückgegeben. Sie können die Zusammenfassung mit einem statischen Formatstring (tool_call_summary_format) **oder** einem Aufrufobjekt (tool_call_summary_formatter) anpassen; das Aufrufobjekt wird einmal pro Werkzeugaufruf ausgewertet.

  • Wenn reflect_on_tool_use auf `True` gesetzt ist, wird eine weitere Modellinferenz mit den Werkzeugaufrufen und Ergebnissen durchgeführt, und die endgültige Antwort wird als TextMessage oder StructuredMessage (bei Verwendung von strukturierter Ausgabe) in chat_message zurückgegeben.

  • reflect_on_tool_use ist standardmäßig auf True gesetzt, wenn output_content_type gesetzt ist.

  • reflect_on_tool_use ist standardmäßig auf False gesetzt, wenn output_content_type nicht gesetzt ist.

• Wenn das Modell mehrere Werkzeugaufrufe zurückgibt, werden diese parallel ausgeführt. Um parallele Werkzeugaufrufe zu deaktivieren, müssen Sie den Modellclient konfigurieren. Setzen Sie z. B. parallel_tool_calls=False für OpenAIChatCompletionClient und AzureOpenAIChatCompletionClient.

• Der Parameter max_tool_iterations steuert, wie viele sequentielle Werkzeugaufruf-Iterationen der Agent in einem einzigen Lauf durchführen kann. Wenn er auf 1 (Standard) gesetzt ist, führt der Agent Werkzeugaufrufe einmal aus und gibt das Ergebnis zurück. Wenn er höher gesetzt ist, kann der Agent zusätzliche Modellaufrufe tätigen, um weitere Werkzeugaufrufe auszuführen, wenn das Modell diese weiterhin anfordert, was mehrstufige werkzeugbasierte Arbeitsabläufe ermöglicht. Der Agent stoppt, wenn entweder das Modell eine Textantwort (anstelle von Werkzeugaufrufen) zurückgibt oder die maximale Anzahl von Iterationen erreicht ist.

Tipp

Standardmäßig werden die Ergebnisse von Werkzeugaufrufen als Antwort zurückgegeben, wenn Werkzeugaufrufe erfolgen. Achten Sie daher genau darauf, wie die Rückgabewerte der Werkzeuge formatiert sind – insbesondere, wenn ein anderer Agent ein bestimmtes Schema erwartet.

• Verwenden Sie `tool_call_summary_format` für eine einfache statische Vorlage.

• Verwenden Sie `tool_call_summary_formatter` für vollständige programmatische Kontrolle (z. B. „große Erfolg-Payloads ausblenden, vollständige Details bei Fehlern anzeigen“).

Hinweis: tool_call_summary_formatter ist **nicht serialisierbar** und wird ignoriert, wenn ein Agent aus YAML/JSON-Konfigurationsdateien geladen oder in diese exportiert wird.

Übergabeverhalten

• Wenn eine Übergabe ausgelöst wird, wird eine HandoffMessage in chat_message zurückgegeben.

• Wenn Werkzeugaufrufe vorhanden sind, werden diese ebenfalls sofort ausgeführt, bevor die Übergabe zurückgegeben wird.

• Die Werkzeugaufrufe und Ergebnisse werden über den context an den Zielagenten übergeben.

Hinweis

Wenn mehrere Übergaben erkannt werden, wird nur die erste Übergabe ausgeführt. Um dies zu vermeiden, deaktivieren Sie parallele Werkzeugaufrufe in der Modellclient-Konfiguration.

Kontextgröße an das Modell begrenzen

Sie können die Anzahl der an das Modell gesendeten Nachrichten begrenzen, indem Sie den Parameter model_context auf ein BufferedChatCompletionContext setzen. Dies begrenzt die Anzahl der kürzlich gesendeten Nachrichten an das Modell und kann nützlich sein, wenn das Modell eine Grenze für die Anzahl der zu verarbeitenden Tokens hat. Eine weitere Option ist die Verwendung eines TokenLimitedChatCompletionContext, das die Anzahl der an das Modell gesendeten Tokens begrenzt. Sie können auch Ihren eigenen Modellkontext erstellen, indem Sie ChatCompletionContext unterklassifizieren.

Streaming-Modus

Der Assistenten-Agent kann im Streaming-Modus verwendet werden, indem model_client_stream=True gesetzt wird. In diesem Modus geben die Methoden on_messages_stream() und BaseChatAgent.run_stream() auch ModelClientStreamingChunkEvent-Nachrichten aus, sobald der Modellclient Antwort-Chunks produziert. Die Chunk-Nachrichten werden nicht in die inneren Nachrichten der endgültigen Antwort aufgenommen.

Parameter:

• name (str) – Der Name des Agenten.

• model_client (ChatCompletionClient) – Der Modellclient, der für die Inferenz verwendet werden soll.

• tools (List[BaseTool[Any, Any] | Callable[..., Any] | Callable[..., Awaitable[Any]]] | None, optional) – Die beim Agenten zu registrierenden Werkzeuge.

• workbench (Workbench | Sequence[Workbench] | None, optional) – Die Workbench oder Liste von Workbenches, die für den Agenten verwendet werden sollen. Werkzeuge können nicht verwendet werden, wenn workbench gesetzt ist und umgekehrt.

• handoffs (List[HandoffBase | str] | None, optional) – Die Übergabekonfigurationen für den Agenten, die es ihm ermöglichen, an andere Agenten zu übergeben, indem er mit einer HandoffMessage antwortet. Die Übergabe wird nur ausgeführt, wenn das Team in Swarm ist. Wenn eine Übergabe eine Zeichenkette ist, sollte sie den Namen des Zielagenten darstellen.

• model_context (ChatCompletionContext | None, optional) – Der Modellkontext zum Speichern und Abrufen von LLMMessage. Er kann mit Anfangsnachrichten vorab geladen werden. Die Anfangsnachrichten werden gelöscht, wenn der Agent zurückgesetzt wird.

• description (str, optional) – Die Beschreibung des Agenten.

• system_message (str, optional) – Die Systemnachricht für das Modell. Wenn angegeben, wird sie beim Aufruf einer Inferenz vor die Nachrichten im Modellkontext gestellt. Setzen Sie sie auf None, um sie zu deaktivieren.

• model_client_stream (bool, optional) – Wenn True, wird der Modellclient im Streaming-Modus verwendet. Die Methoden on_messages_stream() und BaseChatAgent.run_stream() geben auch ModelClientStreamingChunkEvent-Nachrichten aus, sobald der Modellclient Antwort-Chunks produziert. Standardmäßig False.

• reflect_on_tool_use (bool, optional) – Wenn True, führt der Agent eine weitere Modellinferenz mit dem Werkzeugaufruf und dem Ergebnis durch, um eine Antwort zu generieren. Wenn False, wird das Ergebnis des Werkzeugaufrufs als Antwort zurückgegeben. Standardmäßig ist dies True, wenn output_content_type gesetzt ist; wenn output_content_type nicht gesetzt ist, ist dies False.

• output_content_type (type[BaseModel] | None, optional) – Der Ausgabetypp für StructuredMessage-Antworten als Pydantic-Modell. Dies wird zusammen mit dem Modellclient verwendet, um strukturierte Ausgaben zu generieren. Wenn dies gesetzt ist, antwortet der Agent mit einer StructuredMessage anstelle einer TextMessage in der endgültigen Antwort, es sei denn, reflect_on_tool_use ist False und ein Werkzeugaufruf wird getätigt.

• output_content_type_format (str | None, optional) – (Experimentell) Der Formatstring, der für den Inhalt einer StructuredMessage-Antwort verwendet wird.

• max_tool_iterations (int, optional) – Die maximale Anzahl von Werkzeugiterationen, die durchgeführt werden, bis das Modell aufhört, Werkzeugaufrufe zu tätigen. Standardmäßig 1, was bedeutet, dass der Agent die vom Modell gemachten Werkzeugaufrufe nur einmal ausführt und das Ergebnis als ToolCallSummaryMessage oder als TextMessage oder als StructuredMessage (bei Verwendung von strukturierter Ausgabe) in chat_message als endgültige Antwort zurückgibt. Sobald das Modell aufhört, Werkzeugaufrufe zu tätigen, wird der Agent die Ausführung von Werkzeugaufrufen einstellen und das Ergebnis als endgültige Antwort zurückgeben. Der Wert muss größer oder gleich 1 sein.

• tool_call_summary_format (str, optional) – Statische Formatzeichenkette, die auf jedes Ergebnis eines Werkzeugaufrufs angewendet wird, wenn die ToolCallSummaryMessage zusammengestellt wird. Standardmäßig "{result}". Ignoriert, wenn tool_call_summary_formatter angegeben ist. Wenn reflect_on_tool_use auf False gesetzt ist, werden die Zusammenfassungen aller Werkzeugaufrufe mit einem Zeilenumbruch ('n') verkettet und als Antwort zurückgegeben. Platzhalter im Template: {tool_name}, {arguments}, {result}, {is_error}.

• tool_call_summary_formatter (Callable[[FunctionCall, FunctionExecutionResult], str] | None, optional) –

  Ein Aufrufobjekt, das den FunctionCall und dessen FunctionExecutionResult erhält und die Zusammenfassungszeichenkette zurückgibt. Überschreibt tool_call_summary_format, wenn es bereitgestellt wird, und ermöglicht bedingte Logik – z. B. die Ausgabe einer statischen Zeichenkette wie "Tool FooBar erfolgreich ausgeführt." bei Erfolg und eine vollständige Payload (einschließlich aller übergebenen Argumente usw.) nur bei einem Fehler.

  Einschränkung: Das Aufrufobjekt ist nicht serialisierbar; Werte, die über YAML/JSON-Konfigurationen bereitgestellt werden, werden ignoriert.

Hinweis

tool_call_summary_formatter ist nur für die Verwendung im Code vorgesehen. Es kann derzeit nicht über Konfigurationsdateien gespeichert oder wiederhergestellt werden.

memory (Sequence[Memory] | None, optional): Der zu verwendende Speicher für den Agenten. Standardwert ist None. metadata (Dict[str, str] | None, optional): Optionale Metadaten zur Nachverfolgung.

Löst aus:

• ValueError – Wenn Toolnamen nicht eindeutig sind.

• ValueError – Wenn Handoff-Namen nicht eindeutig sind.

• ValueError – Wenn Handoff-Namen nicht eindeutig von Toolnamen sind.

• ValueError – Wenn die maximale Anzahl von Tool-Iterationen kleiner als 1 ist.

Examples

Beispiel 1: Basis-Agent

Das folgende Beispiel zeigt, wie ein Assistenten-Agent mit einem Modellclient erstellt und eine Antwort auf eine einfache Aufgabe generiert wird.

import asyncio
from autogen_ext.models.openai import OpenAIChatCompletionClient
from autogen_agentchat.agents import AssistantAgent


async def main() -> None:
    model_client = OpenAIChatCompletionClient(
        model="gpt-4o",
        # api_key = "your_openai_api_key"
    )
    agent = AssistantAgent(name="assistant", model_client=model_client)

    result = await agent.run(task="Name two cities in North America.")
    print(result)


asyncio.run(main())

Beispiel 2: Token-Streaming mit Modellclient

Dieses Beispiel zeigt, wie ein Assistenten-Agent mit einem Modellclient erstellt und ein Token-Stream generiert wird, indem model_client_stream=True gesetzt wird.

import asyncio
from autogen_ext.models.openai import OpenAIChatCompletionClient
from autogen_agentchat.agents import AssistantAgent


async def main() -> None:
    model_client = OpenAIChatCompletionClient(
        model="gpt-4o",
        # api_key = "your_openai_api_key"
    )
    agent = AssistantAgent(
        name="assistant",
        model_client=model_client,
        model_client_stream=True,
    )

    stream = agent.run_stream(task="Name two cities in North America.")
    async for message in stream:
        print(message)


asyncio.run(main())

source='user' models_usage=None metadata={} content='Name two cities in North America.' type='TextMessage'
source='assistant' models_usage=None metadata={} content='Two' type='ModelClientStreamingChunkEvent'
source='assistant' models_usage=None metadata={} content=' cities' type='ModelClientStreamingChunkEvent'
source='assistant' models_usage=None metadata={} content=' in' type='ModelClientStreamingChunkEvent'
source='assistant' models_usage=None metadata={} content=' North' type='ModelClientStreamingChunkEvent'
source='assistant' models_usage=None metadata={} content=' America' type='ModelClientStreamingChunkEvent'
source='assistant' models_usage=None metadata={} content=' are' type='ModelClientStreamingChunkEvent'
source='assistant' models_usage=None metadata={} content=' New' type='ModelClientStreamingChunkEvent'
source='assistant' models_usage=None metadata={} content=' York' type='ModelClientStreamingChunkEvent'
source='assistant' models_usage=None metadata={} content=' City' type='ModelClientStreamingChunkEvent'
source='assistant' models_usage=None metadata={} content=' and' type='ModelClientStreamingChunkEvent'
source='assistant' models_usage=None metadata={} content=' Toronto' type='ModelClientStreamingChunkEvent'
source='assistant' models_usage=None metadata={} content='.' type='ModelClientStreamingChunkEvent'
source='assistant' models_usage=None metadata={} content=' TERMIN' type='ModelClientStreamingChunkEvent'
source='assistant' models_usage=None metadata={} content='ATE' type='ModelClientStreamingChunkEvent'
source='assistant' models_usage=RequestUsage(prompt_tokens=0, completion_tokens=0) metadata={} content='Two cities in North America are New York City and Toronto. TERMINATE' type='TextMessage'
messages=[TextMessage(source='user', models_usage=None, metadata={}, content='Name two cities in North America.', type='TextMessage'), TextMessage(source='assistant', models_usage=RequestUsage(prompt_tokens=0, completion_tokens=0), metadata={}, content='Two cities in North America are New York City and Toronto. TERMINATE', type='TextMessage')] stop_reason=None

Beispiel 3: Agent mit Tools

Das folgende Beispiel zeigt, wie ein Assistenten-Agent mit einem Modellclient und einem Tool erstellt, ein Nachrichtenstrom für eine Aufgabe generiert und die Nachrichten mit Console auf der Konsole ausgegeben wird.

Das Tool ist eine einfache Funktion, die die aktuelle Zeit zurückgibt. Intern wird die Funktion in ein FunctionTool verpackt und mit dem Modellclient des Agenten verwendet. Der Docstring der Funktion wird als Tool-Beschreibung, der Funktionsname als Tool-Name und die Funktionssignatur einschließlich der Typ-Hints als Tool-Argumente verwendet.

import asyncio
from autogen_ext.models.openai import OpenAIChatCompletionClient
from autogen_agentchat.agents import AssistantAgent
from autogen_agentchat.ui import Console


async def get_current_time() -> str:
    return "The current time is 12:00 PM."


async def main() -> None:
    model_client = OpenAIChatCompletionClient(
        model="gpt-4o",
        # api_key = "your_openai_api_key"
    )
    agent = AssistantAgent(name="assistant", model_client=model_client, tools=[get_current_time])
    await Console(agent.run_stream(task="What is the current time?"))


asyncio.run(main())

Beispiel 4: Agent mit max_tool_iterations

Das folgende Beispiel zeigt, wie der Parameter max_tool_iterations verwendet wird, um zu steuern, wie oft der Agent Tool-Aufrufe in einem einzigen Durchlauf ausführen kann. Dies ist nützlich, wenn der Agent mehrere sequentielle Tool-Operationen durchführen soll, um ein Ziel zu erreichen.

import asyncio
from autogen_ext.models.openai import OpenAIChatCompletionClient
from autogen_agentchat.agents import AssistantAgent
from autogen_agentchat.ui import Console


# Global counter state
counter = 0


def increment_counter() -> str:
    """Increment the counter by 1 and return the current value."""
    global counter
    counter += 1
    return f"Counter incremented to: {counter}"


def get_counter() -> str:
    """Get the current counter value."""
    global counter
    return f"Current counter value: {counter}"


async def main() -> None:
    model_client = OpenAIChatCompletionClient(
        model="gpt-4o",
        # api_key = "your_openai_api_key"
    )

    # Create agent with max_tool_iterations=5 to allow multiple tool calls
    agent = AssistantAgent(
        name="assistant",
        model_client=model_client,
        tools=[increment_counter, get_counter],
        max_tool_iterations=5,  # Allow up to 5 tool call iterations
        reflect_on_tool_use=True,  # Get a final summary after tool calls
    )

    await Console(agent.run_stream(task="Increment the counter 3 times and then tell me the final value."))


asyncio.run(main())

Beispiel 5: Agent mit Model-Context Protocol (MCP) Workbench

Das folgende Beispiel zeigt, wie ein Assistenten-Agent mit einem Modellclient und einer McpWorkbench für die Interaktion mit einem Model-Context Protocol (MCP)-Server erstellt wird.

import asyncio
from autogen_agentchat.agents import AssistantAgent
from autogen_agentchat.ui import Console
from autogen_ext.models.openai import OpenAIChatCompletionClient
from autogen_ext.tools.mcp import StdioServerParams, McpWorkbench


async def main() -> None:
    params = StdioServerParams(
        command="uvx",
        args=["mcp-server-fetch"],
        read_timeout_seconds=60,
    )

    # You can also use `start()` and `stop()` to manage the session.
    async with McpWorkbench(server_params=params) as workbench:
        model_client = OpenAIChatCompletionClient(model="gpt-4.1-nano")
        assistant = AssistantAgent(
            name="Assistant",
            model_client=model_client,
            workbench=workbench,
            reflect_on_tool_use=True,
        )
        await Console(
            assistant.run_stream(task="Go to https://github.com/microsoft/autogen and tell me what you see.")
        )


asyncio.run(main())

Beispiel 6: Agent mit strukturiertem Output und Tool

Das folgende Beispiel zeigt, wie ein Assistenten-Agent mit einem für strukturierten Output konfigurierten Modellclient und einem Tool erstellt wird. Beachten Sie, dass Sie FunctionTool verwenden müssen, um das Tool zu erstellen, und dass strict=True für den Modus mit strukturiertem Output erforderlich ist. Da das Modell für die Verwendung von strukturiertem Output konfiguriert ist, ist die Ausgabe des Reflexions-Responses eine JSON-formatierte Zeichenkette.

import asyncio
from typing import Literal

from autogen_agentchat.agents import AssistantAgent
from autogen_agentchat.ui import Console
from autogen_core.tools import FunctionTool
from autogen_ext.models.openai import OpenAIChatCompletionClient
from pydantic import BaseModel


# Define the structured output format.
class AgentResponse(BaseModel):
    thoughts: str
    response: Literal["happy", "sad", "neutral"]


# Define the function to be called as a tool.
def sentiment_analysis(text: str) -> str:
    """Given a text, return the sentiment."""
    return "happy" if "happy" in text else "sad" if "sad" in text else "neutral"


# Create a FunctionTool instance with `strict=True`,
# which is required for structured output mode.
tool = FunctionTool(sentiment_analysis, description="Sentiment Analysis", strict=True)

# Create an OpenAIChatCompletionClient instance that supports structured output.
model_client = OpenAIChatCompletionClient(
    model="gpt-4o-mini",
)

# Create an AssistantAgent instance that uses the tool and model client.
agent = AssistantAgent(
    name="assistant",
    model_client=model_client,
    tools=[tool],
    system_message="Use the tool to analyze sentiment.",
    output_content_type=AgentResponse,
)


async def main() -> None:
    stream = agent.run_stream(task="I am happy today!")
    await Console(stream)


asyncio.run(main())

---------- assistant ----------
[FunctionCall(id='call_tIZjAVyKEDuijbBwLY6RHV2p', arguments='{"text":"I am happy today!"}', name='sentiment_analysis')]
---------- assistant ----------
[FunctionExecutionResult(content='happy', call_id='call_tIZjAVyKEDuijbBwLY6RHV2p', is_error=False)]
---------- assistant ----------
{"thoughts":"The user expresses a clear positive emotion by stating they are happy today, suggesting an upbeat mood.","response":"happy"}

Beispiel 7: Agent mit begrenztem Modellkontext

Das folgende Beispiel zeigt, wie ein BufferedChatCompletionContext verwendet wird, das nur die letzten 2 Nachrichten (1 Benutzer + 1 Assistent) behält. Ein begrenzter Modellkontext ist nützlich, wenn das Modell eine Beschränkung hinsichtlich der Anzahl der verarbeitbaren Token hat.

import asyncio

from autogen_agentchat.agents import AssistantAgent
from autogen_core.model_context import BufferedChatCompletionContext
from autogen_ext.models.openai import OpenAIChatCompletionClient


async def main() -> None:
    # Create a model client.
    model_client = OpenAIChatCompletionClient(
        model="gpt-4o-mini",
        # api_key = "your_openai_api_key"
    )

    # Create a model context that only keeps the last 2 messages (1 user + 1 assistant).
    model_context = BufferedChatCompletionContext(buffer_size=2)

    # Create an AssistantAgent instance with the model client and context.
    agent = AssistantAgent(
        name="assistant",
        model_client=model_client,
        model_context=model_context,
        system_message="You are a helpful assistant.",
    )

    result = await agent.run(task="Name two cities in North America.")
    print(result.messages[-1].content)  # type: ignore

    result = await agent.run(task="My favorite color is blue.")
    print(result.messages[-1].content)  # type: ignore

    result = await agent.run(task="Did I ask you any question?")
    print(result.messages[-1].content)  # type: ignore


asyncio.run(main())

Two cities in North America are New York City and Toronto.
That's great! Blue is often associated with calmness and serenity. Do you have a specific shade of blue that you like, or any particular reason why it's your favorite?
No, you didn't ask a question. I apologize for any misunderstanding. If you have something specific you'd like to discuss or ask, feel free to let me know!

Beispiel 8: Agent mit Speicher

Das folgende Beispiel zeigt, wie eine listenbasierte Speicherung mit dem Assistenten-Agenten verwendet wird. Der Speicher wird mit einigen anfänglichen Inhalten vorab geladen. Intern wird der Speicher verwendet, um den Modellkontext vor der Inferenz zu aktualisieren, mithilfe der Methode update_context().

import asyncio

from autogen_agentchat.agents import AssistantAgent
from autogen_core.memory import ListMemory, MemoryContent
from autogen_ext.models.openai import OpenAIChatCompletionClient


async def main() -> None:
    # Create a model client.
    model_client = OpenAIChatCompletionClient(
        model="gpt-4o-mini",
        # api_key = "your_openai_api_key"
    )

    # Create a list-based memory with some initial content.
    memory = ListMemory()
    await memory.add(MemoryContent(content="User likes pizza.", mime_type="text/plain"))
    await memory.add(MemoryContent(content="User dislikes cheese.", mime_type="text/plain"))

    # Create an AssistantAgent instance with the model client and memory.
    agent = AssistantAgent(
        name="assistant",
        model_client=model_client,
        memory=[memory],
        system_message="You are a helpful assistant.",
    )

    result = await agent.run(task="What is a good dinner idea?")
    print(result.messages[-1].content)  # type: ignore


asyncio.run(main())

How about making a delicious pizza without cheese? You can create a flavorful veggie pizza with a variety of toppings. Here's a quick idea:

**Veggie Tomato Sauce Pizza**
- Start with a pizza crust (store-bought or homemade).
- Spread a layer of marinara or tomato sauce evenly over the crust.
- Top with your favorite vegetables like bell peppers, mushrooms, onions, olives, and spinach.
- Add some protein if you'd like, such as grilled chicken or pepperoni (ensure it's cheese-free).
- Sprinkle with herbs like oregano and basil, and maybe a drizzle of olive oil.
- Bake according to the crust instructions until the edges are golden and the veggies are cooked.

Serve it with a side salad or some garlic bread to complete the meal! Enjoy your dinner!

Beispiel 9: Agent mit `o1-mini`

Das folgende Beispiel zeigt, wie das Modell o1-mini mit dem Assistenten-Agenten verwendet wird.

import asyncio
from autogen_ext.models.openai import OpenAIChatCompletionClient
from autogen_agentchat.agents import AssistantAgent


async def main() -> None:
    model_client = OpenAIChatCompletionClient(
        model="o1-mini",
        # api_key = "your_openai_api_key"
    )
    # The system message is not supported by the o1 series model.
    agent = AssistantAgent(name="assistant", model_client=model_client, system_message=None)

    result = await agent.run(task="What is the capital of France?")
    print(result.messages[-1].content)  # type: ignore


asyncio.run(main())

Hinweis

Die Modelle o1-preview und o1-mini unterstützen keine Systemnachricht und keinen Funktionsaufruf. Daher sollte system_message auf None gesetzt werden, und tools sowie handoffs sollten nicht gesetzt werden. Weitere Informationen finden Sie unter o1 Beta-Einschränkungen.

Beispiel 10: Agent, der ein Reasoning-Modell mit benutzerdefiniertem Modellkontext verwendet.

Das folgende Beispiel zeigt, wie ein Reasoning-Modell (DeepSeek R1) mit dem Assistenten-Agenten verwendet wird. Der Modellkontext wird verwendet, um das Gedankenfeld aus der Assistentennachricht herauszufiltern.

import asyncio
from typing import List

from autogen_agentchat.agents import AssistantAgent
from autogen_core.model_context import UnboundedChatCompletionContext
from autogen_core.models import AssistantMessage, LLMMessage, ModelFamily
from autogen_ext.models.ollama import OllamaChatCompletionClient


class ReasoningModelContext(UnboundedChatCompletionContext):
    """A model context for reasoning models."""

    async def get_messages(self) -> List[LLMMessage]:
        messages = await super().get_messages()
        # Filter out thought field from AssistantMessage.
        messages_out: List[LLMMessage] = []
        for message in messages:
            if isinstance(message, AssistantMessage):
                message.thought = None
            messages_out.append(message)
        return messages_out


# Create an instance of the model client for DeepSeek R1 hosted locally on Ollama.
model_client = OllamaChatCompletionClient(
    model="deepseek-r1:8b",
    model_info={
        "vision": False,
        "function_calling": False,
        "json_output": False,
        "family": ModelFamily.R1,
        "structured_output": True,
    },
)

agent = AssistantAgent(
    "reasoning_agent",
    model_client=model_client,
    model_context=ReasoningModelContext(),  # Use the custom model context.
)


async def run_reasoning_agent() -> None:
    result = await agent.run(task="What is the capital of France?")
    print(result)


asyncio.run(run_reasoning_agent())

Detaillierte Beispiele und Verwendungszwecke finden Sie im Abschnitt Beispiele unten.

component_version: ClassVar[int] = 2

Die Version der Komponente, falls Schema-Inkompatibilitäten auftreten, sollte diese aktualisiert werden.

component_config_schema

alias von AssistantAgentConfig

component_provider_override: ClassVar[str | None] = 'autogen_agentchat.agents.AssistantAgent'

Überschreibe den Anbieter-String für die Komponente. Dies sollte verwendet werden, um zu verhindern, dass interne Modulnamen Teil des Modulnamens werden.

property produced_message_types: Sequence[type[BaseChatMessage]]

Gibt die Nachrichtentypen zurück, die dieser Agent produzieren kann.

Gibt zurück:

Sequenz von Nachrichtentypen, die dieser Agent generieren kann

property model_context: ChatCompletionContext

Gibt den vom Agenten verwendeten Modellkontext zurück.

Gibt zurück:

Der Chat-Vervollständigungskontext für diesen Agenten

async on_messages(messages: Sequence[BaseChatMessage], cancellation_token: CancellationToken) → Response

Verarbeitet eingehende Nachrichten und generiert eine Antwort.

Parameter:

• messages – Sequenz von Nachrichten, die verarbeitet werden sollen

• cancellation_token – Token zum Abbrechen der Operation

Gibt zurück:

Antwort, die die Antwort des Agenten enthält

async on_messages_stream(messages: Sequence[BaseChatMessage], cancellation_token: CancellationToken) → AsyncGenerator[BaseAgentEvent | BaseChatMessage | Response, None]

Verarbeitet Nachrichten und streamt die Antwort.

Parameter:

• messages – Sequenz von Nachrichten, die verarbeitet werden sollen

• cancellation_token – Token zum Abbrechen der Operation

Gibt:

Ereignisse, Nachrichten und die endgültige Antwort während der Verarbeitung

async on_reset(cancellation_token: CancellationToken) → None

Setzt den Assistenten-Agenten auf seinen Initialzustand zurück.

async save_state() → Mapping[str, Any]

Speichert den aktuellen Zustand des Assistenten-Agenten.

async load_state(state: Mapping[str, Any]) → None

Lädt den Zustand des Assistenten-Agenten.

class CodeExecutorAgent(name: str, code_executor: CodeExecutor, *, model_client: ChatCompletionClient | None = None, model_context: ChatCompletionContext | None = None, model_client_stream: bool = False, max_retries_on_error: int = 0, description: str | None = None, system_message: str | None = DEFAULT_SYSTEM_MESSAGE, sources: Sequence[str] | None = None, supported_languages: List[str] | None = None, approval_func: Callable[[ApprovalRequest], ApprovalResponse] | Callable[[ApprovalRequest], Awaitable[ApprovalResponse]] | None = None)

Basiert auf: BaseChatAgent, Component[CodeExecutorAgentConfig]

(Experimentell) Ein Agent, der Code-Snippets basierend auf Benutzeranweisungen generiert und ausführt.

Hinweis

Dieser Agent ist experimentell und kann sich in zukünftigen Versionen ändern.

Er wird typischerweise innerhalb eines Teams mit einem anderen Agenten verwendet, der Code-Snippets generiert, die ausgeführt werden sollen, oder allein mit einem bereitgestellten model_client, damit er Code basierend auf Benutzeranfragen generieren, ausführen und die Code-Ergebnisse reflektieren kann.

Wenn er mit model_client verwendet wird, generiert er Code-Snippets mithilfe des Modells und führt sie mit dem bereitgestellten code_executor aus. Das Modell wird auch die Ergebnisse der Code-Ausführung reflektieren. Der Agent gibt die endgültige Reflexionsergebnis vom Modell als endgültige Antwort aus.

Wenn er ohne model_client verwendet wird, führt er nur Codeblöcke aus, die in TextMessage-Nachrichten gefunden werden, und gibt die Ausgabe der Code-Ausführung zurück.

Hinweis

Die Verwendung von AssistantAgent mit PythonCodeExecutionTool ist eine Alternative zu diesem Agenten. Das Modell für diesen Agenten muss jedoch eine korrekt maskierte Code-Zeichenkette als Parameter für das Tool generieren.

Parameter:

• name (str) – Der Name des Agenten.

• code_executor (CodeExecutor) – Der Code-Executor, der für die Ausführung von Code verantwortlich ist, der in Nachrichten empfangen wird (empfohlen wird DockerCommandLineCodeExecutor. Siehe Beispiel unten)

• model_client (ChatCompletionClient, optional) – Der Modellclient, der für Inferenz und Code-Generierung verwendet wird. Wenn nicht angegeben, führt der Agent nur Codeblöcke aus, die in Eingabenachrichten gefunden wurden. Derzeit muss das Modell den strukturierten Output-Modus unterstützen, der für den automatischen Wiederholungsmechanismus erforderlich ist.

• model_client_stream (bool, optional) – Wenn True, wird der Modellclient im Streaming-Modus verwendet. Die Methoden on_messages_stream() und BaseChatAgent.run_stream() geben auch ModelClientStreamingChunkEvent-Nachrichten aus, während der Modellclient Antwort-Chunks produziert. Standardwert ist False.

• description (str, optional) – Die Beschreibung des Agenten. Wenn nicht angegeben, wird DEFAULT_AGENT_DESCRIPTION verwendet.

• system_message (str, optional) – Die Systemnachricht für das Modell. Wenn angegeben, wird sie den Nachrichten im Modellkontext vorangestellt, wenn eine Inferenz durchgeführt wird. Auf None setzen, um sie zu deaktivieren. Standardwert ist DEFAULT_SYSTEM_MESSAGE. Dies wird nur verwendet, wenn model_client angegeben ist.

• sources (Sequence[str], optional) – Überprüfen Sie nur Nachrichten von den angegebenen Agenten auf den auszuführenden Code. Dies ist nützlich, wenn der Agent Teil eines Gruppenchats ist und Sie die Codeausführung auf Nachrichten von bestimmten Agenten beschränken möchten. Wenn nicht angegeben, werden alle Nachrichten auf Codeblöcke überprüft. Dies wird nur verwendet, wenn model_client nicht angegeben ist.

• max_retries_on_error (int, optional) – Die maximale Anzahl von Wiederholungen bei Fehlern. Wenn die Codeausführung fehlschlägt, versucht der Agent bis zu dieser Anzahl von Malen eine Wiederholung. Wenn die Codeausführung nach dieser Anzahl von Wiederholungen fehlschlägt, gibt der Agent ein Reflexionsergebnis aus.

• supported_languages (List[str], optional) – Liste der Programmiersprachen, die aus der Agentenantwort geparst und ausgeführt werden. Andere werden ignoriert. Standardwert ist DEFAULT_SUPPORTED_LANGUAGES.

• approval_func (Optional[Union[Callable[[ApprovalRequest], ApprovalResponse], Callable[[ApprovalRequest], Awaitable[ApprovalResponse]]]], optional) – Eine Funktion, die vor jeder Codeausführung aufgerufen wird, um die Genehmigung zu erhalten. Die Funktion nimmt eine ApprovalRequest, die den auszuführenden Code und den aktuellen Kontext enthält, und gibt eine ApprovalResponse zurück. Die Funktion kann synchron oder asynchron sein. Wenn None (Standard) gesetzt ist, wird die gesamte Codeausführung automatisch genehmigt. Wenn sie gesetzt ist, kann der Agent nicht mit dump_component() serialisiert werden.

Hinweis

Es wird empfohlen, dass der CodeExecutorAgent einen Docker-Container zur Codeausführung verwendet. Dies stellt sicher, dass der vom Modell generierte Code in einer isolierten Umgebung ausgeführt wird. Um Docker zu verwenden, muss Docker auf Ihrem System installiert und ausgeführt werden. Befolgen Sie die Installationsanweisungen für Docker.

Hinweis

Der Code-Executor verarbeitet nur Code, der korrekt in Markdown-Codeblöcken mit dreifachen Backticks formatiert ist. Zum Beispiel

```python
print("Hello World")
```

# or

```sh
echo "Hello World"
```

In diesem Beispiel zeigen wir, wie ein CodeExecutorAgent-Agent eingerichtet wird, der den DockerCommandLineCodeExecutor zur Ausführung von Code-Snippets in einem Docker-Container verwendet. Der Parameter work_dir gibt an, wo alle ausgeführten Dateien zunächst lokal gespeichert werden, bevor sie im Docker-Container ausgeführt werden.

import asyncio
from autogen_agentchat.agents import CodeExecutorAgent, ApprovalRequest, ApprovalResponse
from autogen_agentchat.messages import TextMessage
from autogen_ext.code_executors.docker import DockerCommandLineCodeExecutor
from autogen_core import CancellationToken


def simple_approval_func(request: ApprovalRequest) -> ApprovalResponse:
    """Simple approval function that requests user input for code execution approval."""
    print("Code execution approval requested:")
    print("=" * 50)
    print(request.code)
    print("=" * 50)

    while True:
        user_input = input("Do you want to execute this code? (y/n): ").strip().lower()
        if user_input in ['y', 'yes']:
            return ApprovalResponse(approved=True, reason='Approved by user')
        elif user_input in ['n', 'no']:
            return ApprovalResponse(approved=False, reason='Denied by user')
        else:
            print("Please enter 'y' for yes or 'n' for no.")


async def run_code_executor_agent() -> None:
    # Create a code executor agent that uses a Docker container to execute code.
    code_executor = DockerCommandLineCodeExecutor(work_dir="coding")
    await code_executor.start()
    code_executor_agent = CodeExecutorAgent(
        "code_executor",
        code_executor=code_executor,
        approval_func=simple_approval_func
    )

    # Run the agent with a given code snippet.
    task = TextMessage(
        content='''Here is some code
```python
print('Hello world')
```
''',
        source="user",
    )
    response = await code_executor_agent.on_messages([task], CancellationToken())
    print(response.chat_message)

    # Stop the code executor.
    await code_executor.stop()


asyncio.run(run_code_executor_agent())

In diesem Beispiel zeigen wir, wie ein CodeExecutorAgent-Agent eingerichtet wird, der DeviceRequest verwendet, um eine GPU für CUDA-beschleunigte Codeausführung für den Container bereitzustellen.

import asyncio
from autogen_agentchat.agents import CodeExecutorAgent
from autogen_agentchat.messages import TextMessage
from autogen_ext.code_executors.docker import DockerCommandLineCodeExecutor
from autogen_core import CancellationToken
from docker.types import DeviceRequest


async def run_code_executor_agent() -> None:
    # Create a code executor agent that uses a Docker container to execute code.
    code_executor = DockerCommandLineCodeExecutor(
        work_dir="coding", device_requests=[DeviceRequest(count=-1, capabilities=[["gpu"]])]
    )
    await code_executor.start()
    code_executor_agent = CodeExecutorAgent("code_executor", code_executor=code_executor)

    # Display the GPU information
    task = TextMessage(
        content='''Here is some code
```sh
nvidia-smi
```
''',
        source="user",
    )
    response = await code_executor_agent.on_messages([task], CancellationToken())
    print(response.chat_message)

    # Stop the code executor.
    await code_executor.stop()


asyncio.run(run_code_executor_agent())

Im folgenden Beispiel zeigen wir, wie der CodeExecutorAgent ohne den Parameter model_client eingerichtet wird, um Codeblöcke auszuführen, die von anderen Agenten in einem Gruppenchat generiert wurden, unter Verwendung des DockerCommandLineCodeExecutor.

import asyncio

from autogen_ext.code_executors.docker import DockerCommandLineCodeExecutor
from autogen_ext.models.openai import OpenAIChatCompletionClient

from autogen_agentchat.agents import AssistantAgent, CodeExecutorAgent, ApprovalRequest, ApprovalResponse
from autogen_agentchat.conditions import MaxMessageTermination
from autogen_agentchat.teams import RoundRobinGroupChat
from autogen_agentchat.ui import Console

termination_condition = MaxMessageTermination(3)


def group_chat_approval_func(request: ApprovalRequest) -> ApprovalResponse:
    """Approval function for group chat that allows basic Python operations."""
    # Allow common safe operations
    safe_operations = ["print(", "import ", "def ", "class ", "if ", "for ", "while "]
    if any(op in request.code for op in safe_operations):
        return ApprovalResponse(approved=True, reason='Safe Python operation')

    # Deny file system operations in group chat
    dangerous_operations = ["open(", "file(", "os.", "subprocess", "eval(", "exec("]
    if any(op in request.code for op in dangerous_operations):
        return ApprovalResponse(approved=False, reason='File system or dangerous operation not allowed')

    return ApprovalResponse(approved=True, reason='Operation approved')


async def main() -> None:
    model_client = OpenAIChatCompletionClient(model="gpt-4o")

    # define the Docker CLI Code Executor
    code_executor = DockerCommandLineCodeExecutor(work_dir="coding")

    # start the execution container
    await code_executor.start()

    code_executor_agent = CodeExecutorAgent(
        "code_executor_agent",
        code_executor=code_executor,
        approval_func=group_chat_approval_func
    )
    coder_agent = AssistantAgent("coder_agent", model_client=model_client)

    groupchat = RoundRobinGroupChat(
        participants=[coder_agent, code_executor_agent], termination_condition=termination_condition
    )

    task = "Write python code to print Hello World!"
    await Console(groupchat.run_stream(task=task))

    # stop the execution container
    await code_executor.stop()


asyncio.run(main())

---------- user ----------
Write python code to print Hello World!
---------- coder_agent ----------
Certainly! Here's a simple Python code to print "Hello World!":

```python
print("Hello World!")
```

You can run this code in any Python environment to display the message.
---------- code_executor_agent ----------
Hello World!

Im folgenden Beispiel zeigen wir, wie der CodeExecutorAgent mit einem model_client eingerichtet wird, der seinen eigenen Code ohne die Hilfe eines anderen Agenten generieren kann, und ihn in einem DockerCommandLineCodeExecutor ausführt. Es wird auch gezeigt, wie eine modellbasierte Genehmigungsfunktion verwendet wird, die den Code vor der Ausführung auf Sicherheit prüft.

import asyncio

from autogen_ext.code_executors.docker import DockerCommandLineCodeExecutor
from autogen_ext.models.openai import OpenAIChatCompletionClient
from autogen_core.models import SystemMessage, UserMessage

from autogen_agentchat.agents import CodeExecutorAgent, ApprovalRequest, ApprovalResponse
from autogen_agentchat.conditions import TextMessageTermination
from autogen_agentchat.ui import Console

termination_condition = TextMessageTermination("code_executor_agent")


async def main() -> None:
    model_client = OpenAIChatCompletionClient(model="gpt-4o")

    async def model_client_approval_func(request: ApprovalRequest) -> ApprovalResponse:
        instruction = "Approve or reject the code in the last message based on whether it is dangerous or not. Use the following JSON format for your response: {approved: true/false, reason: 'your reason here'}"
        response = await model_client.create(
            messages=[SystemMessage(content=instruction)]
            + request.context
            + [UserMessage(content=request.code, source="user")],
            json_output=ApprovalResponse,
        )
        assert isinstance(response.content, str)
        return ApprovalResponse.model_validate_json(response.content)

    # define the Docker CLI Code Executor
    code_executor = DockerCommandLineCodeExecutor(work_dir="coding")

    # start the execution container
    await code_executor.start()

    code_executor_agent = CodeExecutorAgent(
        "code_executor_agent",
        code_executor=code_executor,
        model_client=model_client,
        approval_func=model_client_approval_func,
    )

    task = "Write python code to print Hello World!"
    await Console(code_executor_agent.run_stream(task=task))

    # stop the execution container
    await code_executor.stop()


asyncio.run(main())

---------- user ----------
Write python code to print Hello World!
---------- code_executor_agent ----------
Certainly! Here is a simple Python code to print "Hello World!" to the console:

```python
print("Hello World!")
```

Let's execute it to confirm the output.
---------- code_executor_agent ----------
Hello World!

---------- code_executor_agent ----------
The code has been executed successfully, and it printed "Hello World!" as expected. If you have any more requests or questions, feel free to ask!

DEFAULT_TERMINAL_DESCRIPTION = 'Ein Computerkonsole, die keine andere Aktion ausführt, als Python-Skripte (in ```python Codeblöcke eingeschlossen), oder sh Shell-Skripte (in ```sh Codeblöcke eingeschlossen) auszuführen.'

DEFAULT_AGENT_DESCRIPTION = 'Ein Code-Ausführungs-Agent, der Python- und Shell-Skripte basierend auf Benutzeranweisungen generiert und ausführt. Er gewährleistet Korrektheit, Effizienz und minimale Fehler und behandelt sachgemäß Randfälle.'

DEFAULT_SYSTEM_MESSAGE = 'Sie sind ein Code Execution Agent. Ihre Aufgabe ist es, Python-Code und Shell-Skripte basierend auf Benutzeranweisungen zu generieren und auszuführen, wobei Korrektheit, Effizienz und minimale Fehler sichergestellt werden. Behandeln Sie Randfälle anmutig. Python-Code sollte in ```python Code-Blöcken und sh Shell-Skripte sollten in ```sh Code-Blöcken zur Ausführung bereitgestellt werden.'

NO_CODE_BLOCKS_FOUND_MESSAGE = 'Keine Code-Blöcke im Thread gefunden. Bitte stellen Sie mindestens einen Markdown-kodierten Code-Block zur Ausführung bereit (d.h., kodieren Sie Code in ```python oder ```sh Code-Blöcken).'

DEFAULT_SUPPORTED_LANGUAGES = ['python', 'sh']

component_config_schema

alias von CodeExecutorAgentConfig

component_provider_override: ClassVar[str | None] = 'autogen_agentchat.agents.CodeExecutorAgent'

Überschreibe den Anbieter-String für die Komponente. Dies sollte verwendet werden, um zu verhindern, dass interne Modulnamen Teil des Modulnamens werden.

property produced_message_types: Sequence[type[BaseChatMessage]]

Die vom Code-Executor-Agenten erzeugten Nachrichtentypen.

property model_context: ChatCompletionContext

Der vom Agenten verwendete Modellkontext.

async on_messages(messages: Sequence[BaseChatMessage], cancellation_token: CancellationToken) → Response

Verarbeitet eingehende Nachrichten und gibt eine Antwort zurück.

Hinweis

Agenten sind zustandsbehaftet, und die an diese Methode übergebenen Nachrichten sollten die neuen Nachrichten seit dem letzten Aufruf dieser Methode sein. Der Agent sollte seinen Zustand zwischen den Aufrufen dieser Methode beibehalten. Wenn der Agent sich beispielsweise die vorherigen Nachrichten merken muss, um auf die aktuelle Nachricht zu reagieren, sollte er die vorherigen Nachrichten im Agentenzustand speichern.

async on_messages_stream(messages: Sequence[BaseChatMessage], cancellation_token: CancellationToken) → AsyncGenerator[BaseAgentEvent | BaseChatMessage | Response, None]

Verarbeitet eingehende Nachrichten mit dem Assistenten-Agenten und gibt Ereignisse/Antworten aus, sobald sie eintreten.

async extract_code_blocks_from_messages(messages: Sequence[BaseChatMessage]) → List[CodeBlock]

async execute_code_block(code_blocks: List[CodeBlock], cancellation_token: CancellationToken) → CodeResult

async on_reset(cancellation_token: CancellationToken) → None

Es ist eine No-Op, da der Code-Executor-Agent keinen veränderlichen Zustand hat.

_to_config() → CodeExecutorAgentConfig

Gib die Konfiguration aus, die erforderlich wäre, um eine neue Instanz einer Komponente zu erstellen, die der Konfiguration dieser Instanz entspricht.

Gibt zurück:

T – Die Konfiguration der Komponente.

classmethod _from_config(config: CodeExecutorAgentConfig) → Self

Erstelle eine neue Instanz der Komponente aus einem Konfigurationsobjekt.

Parameter:

config (T) – Das Konfigurationsobjekt.

Gibt zurück:

Self – Die neue Instanz der Komponente.

class SocietyOfMindAgent(name: str, team: Team, model_client: ChatCompletionClient, *, description: str = DEFAULT_DESCRIPTION, instruction: str = DEFAULT_INSTRUCTION, response_prompt: str = DEFAULT_RESPONSE_PROMPT, model_context: ChatCompletionContext | None = None)

Bases: BaseChatAgent, Component[SocietyOfMindAgentConfig]

Ein Agent, der ein inneres Team von Agenten zur Generierung von Antworten verwendet.

Jedes Mal, wenn die Methode on_messages() oder on_messages_stream() des Agenten aufgerufen wird, führt er das innere Team von Agenten aus und verwendet dann den Modellclient, um eine Antwort basierend auf den Nachrichten des inneren Teams zu generieren. Sobald die Antwort generiert wurde, setzt der Agent das innere Team zurück, indem er Team.reset() aufruft.

Kontextgröße an das Modell begrenzen

Sie können die Anzahl der an das Modell gesendeten Nachrichten begrenzen, indem Sie den Parameter model_context auf ein BufferedChatCompletionContext setzen. Dies begrenzt die Anzahl der kürzlich gesendeten Nachrichten an das Modell und kann nützlich sein, wenn das Modell eine Begrenzung der zu verarbeitenden Tokens hat. Sie können auch Ihren eigenen Modellkontext erstellen, indem Sie ChatCompletionContext unterklassifizieren.

Parameter:

• name (str) – Der Name des Agenten.

• team (Team) – Das zu verwendende Team von Agenten.

• model_client (ChatCompletionClient) – Der Modellclient, der zur Vorbereitung von Antworten verwendet wird.

• description (str, optional) – Die Beschreibung des Agenten.

• instruction (str, optional) – Die Anweisung, die bei der Generierung einer Antwort mit den Nachrichten des inneren Teams verwendet wird. Standardmäßig DEFAULT_INSTRUCTION. Nimmt die Rolle von 'system' an.

• response_prompt (str, optional) – Der Antwort-Prompt, der bei der Generierung einer Antwort mit den Nachrichten des inneren Teams verwendet wird. Standardmäßig DEFAULT_RESPONSE_PROMPT. Nimmt die Rolle von 'system' an.

• model_context (ChatCompletionContext | None, optional) – Der Modellkontext zum Speichern und Abrufen von LLMMessage. Er kann mit Anfangsnachrichten vorab geladen werden. Die Anfangsnachrichten werden gelöscht, wenn der Agent zurückgesetzt wird.

Beispiel

import asyncio
from autogen_agentchat.ui import Console
from autogen_agentchat.agents import AssistantAgent, SocietyOfMindAgent
from autogen_ext.models.openai import OpenAIChatCompletionClient
from autogen_agentchat.teams import RoundRobinGroupChat
from autogen_agentchat.conditions import TextMentionTermination


async def main() -> None:
    model_client = OpenAIChatCompletionClient(model="gpt-4o")

    agent1 = AssistantAgent("assistant1", model_client=model_client, system_message="You are a writer, write well.")
    agent2 = AssistantAgent(
        "assistant2",
        model_client=model_client,
        system_message="You are an editor, provide critical feedback. Respond with 'APPROVE' if the text addresses all feedbacks.",
    )
    inner_termination = TextMentionTermination("APPROVE")
    inner_team = RoundRobinGroupChat([agent1, agent2], termination_condition=inner_termination)

    society_of_mind_agent = SocietyOfMindAgent("society_of_mind", team=inner_team, model_client=model_client)

    agent3 = AssistantAgent(
        "assistant3", model_client=model_client, system_message="Translate the text to Spanish."
    )
    team = RoundRobinGroupChat([society_of_mind_agent, agent3], max_turns=2)

    stream = team.run_stream(task="Write a short story with a surprising ending.")
    await Console(stream)


asyncio.run(main())

component_config_schema

alias von SocietyOfMindAgentConfig

component_provider_override: ClassVar[str | None] = 'autogen_agentchat.agents.SocietyOfMindAgent'

Überschreibe den Anbieter-String für die Komponente. Dies sollte verwendet werden, um zu verhindern, dass interne Modulnamen Teil des Modulnamens werden.

DEFAULT_INSTRUCTION = 'Zuvor wurde Ihnen aufgetragen, eine Anfrage zu erfüllen. Sie und Ihr Team haben fleißig daran gearbeitet, diese Anfrage zu bearbeiten. Hier ist ein Transkript dieser Unterhaltung:'

Die Standardanweisung, die bei der Generierung einer Antwort mit den Nachrichten des inneren Teams verwendet wird. Die Anweisung wird den Nachrichten des inneren Teams vorangestellt, wenn eine Antwort mit dem Modell generiert wird. Sie nimmt die Rolle von 'system' an.

Typ:

str

DEFAULT_RESPONSE_PROMPT = 'Geben Sie eine eigenständige Antwort auf die ursprüngliche Anfrage aus, ohne irgendeine der Zwischengespräche zu erwähnen.'

Der Standard-Antwort-Prompt, der bei der Generierung einer Antwort mit den Nachrichten des inneren Teams verwendet wird. Er nimmt die Rolle von 'system' an.

Typ:

str

DEFAULT_DESCRIPTION = 'Ein Agent, der ein inneres Team von Agenten zur Generierung von Antworten verwendet.'

Die Standardbeschreibung für einen SocietyOfMindAgent.

Typ:

str

property produced_message_types: Sequence[type[BaseChatMessage]]

Die Arten von Nachrichten, die der Agent im Feld Response.chat_message produziert. Sie müssen BaseChatMessage-Typen sein.

property model_context: ChatCompletionContext

Der vom Agenten verwendete Modellkontext.

async on_messages(messages: Sequence[BaseChatMessage], cancellation_token: CancellationToken) → Response

Verarbeitet eingehende Nachrichten und gibt eine Antwort zurück.

Hinweis

Agenten sind zustandsbehaftet, und die an diese Methode übergebenen Nachrichten sollten die neuen Nachrichten seit dem letzten Aufruf dieser Methode sein. Der Agent sollte seinen Zustand zwischen den Aufrufen dieser Methode beibehalten. Wenn der Agent sich beispielsweise die vorherigen Nachrichten merken muss, um auf die aktuelle Nachricht zu reagieren, sollte er die vorherigen Nachrichten im Agentenzustand speichern.

async on_messages_stream(messages: Sequence[BaseChatMessage], cancellation_token: CancellationToken) → AsyncGenerator[BaseAgentEvent | BaseChatMessage | Response, None]

Verarbeitet eingehende Nachrichten und gibt einen Strom von Nachrichten und das letzte Element als Antwort zurück. Die Basisimplementierung in BaseChatAgent ruft einfach on_messages() auf und gibt die Nachrichten in der Antwort aus.

Hinweis

Agenten sind zustandsbehaftet, und die an diese Methode übergebenen Nachrichten sollten die neuen Nachrichten seit dem letzten Aufruf dieser Methode sein. Der Agent sollte seinen Zustand zwischen den Aufrufen dieser Methode beibehalten. Wenn der Agent sich beispielsweise die vorherigen Nachrichten merken muss, um auf die aktuelle Nachricht zu reagieren, sollte er die vorherigen Nachrichten im Agentenzustand speichern.

async on_reset(cancellation_token: CancellationToken) → None

Setzt den Agenten in seinen Initialzustand zurück.

async save_state() → Mapping[str, Any]

Zustand exportieren. Standardimplementierung für zustandslose Agenten.

async load_state(state: Mapping[str, Any]) → None

Agent aus gespeichertem Zustand wiederherstellen. Standardimplementierung für zustandslose Agenten.

_to_config() → SocietyOfMindAgentConfig

Gib die Konfiguration aus, die erforderlich wäre, um eine neue Instanz einer Komponente zu erstellen, die der Konfiguration dieser Instanz entspricht.

Gibt zurück:

T – Die Konfiguration der Komponente.

classmethod _from_config(config: SocietyOfMindAgentConfig) → Self

Erstelle eine neue Instanz der Komponente aus einem Konfigurationsobjekt.

Parameter:

config (T) – Das Konfigurationsobjekt.

Gibt zurück:

Self – Die neue Instanz der Komponente.

class UserProxyAgent(name: str, *, description: str = 'A human user', input_func: Callable[[str], str] | Callable[[str, CancellationToken | None], Awaitable[str]] | None = None)

Bases: BaseChatAgent, Component[UserProxyAgentConfig]

Ein Agent, der einen menschlichen Benutzer über eine Eingabefunktion darstellen kann.

Dieser Agent kann verwendet werden, um einen menschlichen Benutzer in einem Chat-System darzustellen, indem eine benutzerdefinierte Eingabefunktion bereitgestellt wird.

Hinweis

Die Verwendung von UserProxyAgent versetzt ein laufendes Team in einen temporär blockierten Zustand, bis der Benutzer antwortet. Daher ist es wichtig, die Eingabefunktion des Benutzers zu zeitgesteuert und mit dem CancellationToken abzubrechen, wenn der Benutzer nicht antwortet. Die Eingabefunktion sollte auch Ausnahmen behandeln und bei Bedarf eine Standardantwort zurückgeben.

Für typische Anwendungsfälle, die langsame menschliche Antworten beinhalten, wird empfohlen, Abbruchbedingungen wie HandoffTermination oder SourceMatchTermination zu verwenden, um das laufende Team zu stoppen und die Kontrolle an die Anwendung zurückzugeben. Sie können das Team mit der Benutzereingabe erneut ausführen. Auf diese Weise kann der Zustand des Teams gespeichert und bei Antwort des Benutzers wiederhergestellt werden.

Weitere Informationen finden Sie unter Human-in-the-loop.

Parameter:

• name (str) – Der Name des Agenten.

• description (str, optional) – Eine Beschreibung des Agenten.

• input_func (Optional[Callable[[str], str], Callable[[str, Optional[CancellationToken]], Awaitable[str]]) – Eine Funktion, die eine Eingabeaufforderung entgegennimmt und eine Benutzereingabezeichenfolge zurückgibt.

Beispiele für die Integration mit Web- und UI-Frameworks finden Sie in den folgenden Abschnitten:

• FastAPI

• ChainLit

Beispiel

Einfacher Anwendungsfall

import asyncio
from autogen_core import CancellationToken
from autogen_agentchat.agents import UserProxyAgent
from autogen_agentchat.messages import TextMessage


async def simple_user_agent():
    agent = UserProxyAgent("user_proxy")
    response = await asyncio.create_task(
        agent.on_messages(
            [TextMessage(content="What is your name? ", source="user")],
            cancellation_token=CancellationToken(),
        )
    )
    assert isinstance(response.chat_message, TextMessage)
    print(f"Your name is {response.chat_message.content}")

Beispiel

Abbrechbarer Anwendungsfall

import asyncio
from typing import Any
from autogen_core import CancellationToken
from autogen_agentchat.agents import UserProxyAgent
from autogen_agentchat.messages import TextMessage


token = CancellationToken()
agent = UserProxyAgent("user_proxy")


async def timeout(delay: float):
    await asyncio.sleep(delay)


def cancellation_callback(task: asyncio.Task[Any]):
    token.cancel()


async def cancellable_user_agent():
    try:
        timeout_task = asyncio.create_task(timeout(3))
        timeout_task.add_done_callback(cancellation_callback)
        agent_task = asyncio.create_task(
            agent.on_messages(
                [TextMessage(content="What is your name? ", source="user")],
                cancellation_token=token,
            )
        )
        response = await agent_task
        assert isinstance(response.chat_message, TextMessage)
        print(f"Your name is {response.chat_message.content}")
    except Exception as e:
        print(f"Exception: {e}")
    except BaseException as e:
        print(f"BaseException: {e}")

component_type: ClassVar[ComponentType] = 'agent'

Der logische Typ der Komponente.

component_provider_override: ClassVar[str | None] = 'autogen_agentchat.agents.UserProxyAgent'

Überschreibe den Anbieter-String für die Komponente. Dies sollte verwendet werden, um zu verhindern, dass interne Modulnamen Teil des Modulnamens werden.

component_config_schema

alias von UserProxyAgentConfig

class InputRequestContext

Basiert auf: object

classmethod request_id() → str

property produced_message_types: Sequence[type[BaseChatMessage]]

Nachrichtentypen, die dieser Agent produzieren kann.

async on_messages(messages: Sequence[BaseChatMessage], cancellation_token: CancellationToken) → Response

Verarbeitet eingehende Nachrichten und gibt eine Antwort zurück.

Hinweis

Agenten sind zustandsbehaftet, und die an diese Methode übergebenen Nachrichten sollten die neuen Nachrichten seit dem letzten Aufruf dieser Methode sein. Der Agent sollte seinen Zustand zwischen den Aufrufen dieser Methode beibehalten. Wenn der Agent sich beispielsweise die vorherigen Nachrichten merken muss, um auf die aktuelle Nachricht zu reagieren, sollte er die vorherigen Nachrichten im Agentenzustand speichern.

async on_messages_stream(messages: Sequence[BaseChatMessage], cancellation_token: CancellationToken) → AsyncGenerator[BaseAgentEvent | BaseChatMessage | Response, None]

Behandelt eingehende Nachrichten durch Anfordern einer Benutzereingabe.

async on_reset(cancellation_token: CancellationToken | None = None) → None

Agentenzustand zurücksetzen.

_to_config() → UserProxyAgentConfig

Gib die Konfiguration aus, die erforderlich wäre, um eine neue Instanz einer Komponente zu erstellen, die der Konfiguration dieser Instanz entspricht.

Gibt zurück:

T – Die Konfiguration der Komponente.

classmethod _from_config(config: UserProxyAgentConfig) → Self

Erstelle eine neue Instanz der Komponente aus einem Konfigurationsobjekt.

Parameter:

config (T) – Das Konfigurationsobjekt.

Gibt zurück:

Self – Die neue Instanz der Komponente.

class MessageFilterAgent(name: str, wrapped_agent: BaseChatAgent, filter: MessageFilterConfig)

Basiert auf: BaseChatAgent, Component[MessageFilterAgentConfig]

Ein Wrapper-Agent, der eingehende Nachrichten filtert, bevor er sie an den inneren Agenten weiterleitet.

Warnung

Dies ist eine experimentelle Funktion, und die API kann sich in zukünftigen Versionen ändern.

Dies ist nützlich in Szenarien wie Multi-Agent-Workflows, bei denen ein Agent nur eine Teilmenge der vollständigen Nachrichtenhistorie verarbeiten soll – zum Beispiel nur die letzte Nachricht von jedem Upstream-Agenten oder nur die erste Nachricht von einer bestimmten Quelle.

Die Filterung wird mithilfe von MessageFilterConfig konfiguriert, die unterstützt: - Filtern nach Nachrichtenquelle (z. B. nur Nachrichten von „user“ oder einem anderen Agenten) - Auswahl der ersten N oder letzten N Nachrichten von jeder Quelle - Wenn position None ist, werden alle Nachrichten von dieser Quelle einbezogen

Dieser Agent ist sowohl mit direkter Nachrichtenübermittlung als auch mit Team-basierter Ausführung wie GraphFlow kompatibel.

Beispiel

>>> agent_a = MessageFilterAgent(
...     name="A",
...     wrapped_agent=some_other_agent,
...     filter=MessageFilterConfig(
...         per_source=[
...             PerSourceFilter(source="user", position="first", count=1),
...             PerSourceFilter(source="B", position="last", count=2),
...         ]
...     ),
... )

Beispiel-Anwendungsfall mit Graph

Angenommen, Sie haben einen Schleifen-Multi-Agent-Graphen: A → B → A → B → C.

Sie möchten: - A soll nur die Benutzernachricht und die letzte Nachricht von B sehen - B soll die Benutzernachricht, die letzte Nachricht von A und seine eigenen vorherigen Antworten (zur Reflexion) sehen - C soll die Benutzernachricht und die letzte Nachricht von B sehen

Wickeln Sie die Agenten wie folgt ein:

>>> agent_a = MessageFilterAgent(
...     name="A",
...     wrapped_agent=agent_a_inner,
...     filter=MessageFilterConfig(
...         per_source=[
...             PerSourceFilter(source="user", position="first", count=1),
...             PerSourceFilter(source="B", position="last", count=1),
...         ]
...     ),
... )

>>> agent_b = MessageFilterAgent(
...     name="B",
...     wrapped_agent=agent_b_inner,
...     filter=MessageFilterConfig(
...         per_source=[
...             PerSourceFilter(source="user", position="first", count=1),
...             PerSourceFilter(source="A", position="last", count=1),
...             PerSourceFilter(source="B", position="last", count=10),
...         ]
...     ),
... )

>>> agent_c = MessageFilterAgent(
...     name="C",
...     wrapped_agent=agent_c_inner,
...     filter=MessageFilterConfig(
...         per_source=[
...             PerSourceFilter(source="user", position="first", count=1),
...             PerSourceFilter(source="B", position="last", count=1),
...         ]
...     ),
... )

Definieren Sie dann den Graphen

>>> graph = DiGraph(
...     nodes={
...         "A": DiGraphNode(name="A", edges=[DiGraphEdge(target="B")]),
...         "B": DiGraphNode(
...             name="B",
...             edges=[
...                 DiGraphEdge(target="C", condition="exit"),
...                 DiGraphEdge(target="A", condition="loop"),
...             ],
...         ),
...         "C": DiGraphNode(name="C", edges=[]),
...     },
...     default_start_node="A",
... )

Dadurch wird sichergestellt, dass jeder Agent nur das sieht, was für seine Entscheidungs- oder Aktionslogik erforderlich ist.

component_config_schema

alias von MessageFilterAgentConfig

component_provider_override: ClassVar[str | None] = 'autogen_agentchat.agents.MessageFilterAgent'

Überschreibe den Anbieter-String für die Komponente. Dies sollte verwendet werden, um zu verhindern, dass interne Modulnamen Teil des Modulnamens werden.

property produced_message_types: Sequence[type[BaseChatMessage]]

Die Arten von Nachrichten, die der Agent im Feld Response.chat_message produziert. Sie müssen BaseChatMessage-Typen sein.

async on_messages(messages: Sequence[BaseChatMessage], cancellation_token: CancellationToken) → Response

Verarbeitet eingehende Nachrichten und gibt eine Antwort zurück.

Hinweis

Agenten sind zustandsbehaftet, und die an diese Methode übergebenen Nachrichten sollten die neuen Nachrichten seit dem letzten Aufruf dieser Methode sein. Der Agent sollte seinen Zustand zwischen den Aufrufen dieser Methode beibehalten. Wenn der Agent sich beispielsweise die vorherigen Nachrichten merken muss, um auf die aktuelle Nachricht zu reagieren, sollte er die vorherigen Nachrichten im Agentenzustand speichern.

async on_messages_stream(messages: Sequence[BaseChatMessage], cancellation_token: CancellationToken) → AsyncGenerator[BaseAgentEvent | BaseChatMessage | Response, None]

Verarbeitet eingehende Nachrichten und gibt einen Strom von Nachrichten zurück, wobei das letzte Element die Antwort ist. Die Basisimplementierung in BaseChatAgent ruft einfach on_messages() auf und gibt die Nachrichten in der Antwort zurück.

Hinweis

Agenten sind zustandsbehaftet, und die an diese Methode übergebenen Nachrichten sollten die neuen Nachrichten seit dem letzten Aufruf dieser Methode sein. Der Agent sollte seinen Zustand zwischen den Aufrufen dieser Methode beibehalten. Wenn der Agent sich beispielsweise die vorherigen Nachrichten merken muss, um auf die aktuelle Nachricht zu reagieren, sollte er die vorherigen Nachrichten im Agentenzustand speichern.

async on_reset(cancellation_token: CancellationToken) → None

Setzt den Agenten in seinen Initialzustand zurück.

_to_config() → MessageFilterAgentConfig

Gib die Konfiguration aus, die erforderlich wäre, um eine neue Instanz einer Komponente zu erstellen, die der Konfiguration dieser Instanz entspricht.

Gibt zurück:

T – Die Konfiguration der Komponente.

classmethod _from_config(config: MessageFilterAgentConfig) → MessageFilterAgent

Erstelle eine neue Instanz der Komponente aus einem Konfigurationsobjekt.

Parameter:

config (T) – Das Konfigurationsobjekt.

Gibt zurück:

Self – Die neue Instanz der Komponente.

pydantic model MessageFilterConfig

Bases: BaseModel

JSON-Schema anzeigen

{
   "title": "MessageFilterConfig",
   "type": "object",
   "properties": {
      "per_source": {
         "items": {
            "$ref": "#/$defs/PerSourceFilter"
         },
         "title": "Per Source",
         "type": "array"
      }
   },
   "$defs": {
      "PerSourceFilter": {
         "properties": {
            "source": {
               "title": "Source",
               "type": "string"
            },
            "position": {
               "anyOf": [
                  {
                     "enum": [
                        "first",
                        "last"
                     ],
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Position"
            },
            "count": {
               "anyOf": [
                  {
                     "type": "integer"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Count"
            }
         },
         "required": [
            "source"
         ],
         "title": "PerSourceFilter",
         "type": "object"
      }
   },
   "required": [
      "per_source"
   ]
}

Felder:

• per_source (List[autogen_agentchat.agents._message_filter_agent.PerSourceFilter])

field per_source: List[PerSourceFilter] [Required]

pydantic model PerSourceFilter

Bases: BaseModel

JSON-Schema anzeigen

{
   "title": "PerSourceFilter",
   "type": "object",
   "properties": {
      "source": {
         "title": "Source",
         "type": "string"
      },
      "position": {
         "anyOf": [
            {
               "enum": [
                  "first",
                  "last"
               ],
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Position"
      },
      "count": {
         "anyOf": [
            {
               "type": "integer"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Count"
      }
   },
   "required": [
      "source"
   ]
}

Felder:

• count (int | None)

• position (Literal['first', 'last'] | None)

• source (str)

field source: str [Required]

field position: Literal['first', 'last'] | None = None

field count: int | None = None

pydantic model ApprovalRequest

Bases: BaseModel

Anforderung der Genehmigung zur Codeausführung.

JSON-Schema anzeigen

{
   "title": "ApprovalRequest",
   "description": "Request for approval of code execution.",
   "type": "object",
   "properties": {
      "code": {
         "title": "Code",
         "type": "string"
      },
      "context": {
         "items": {
            "discriminator": {
               "mapping": {
                  "AssistantMessage": "#/$defs/AssistantMessage",
                  "FunctionExecutionResultMessage": "#/$defs/FunctionExecutionResultMessage",
                  "SystemMessage": "#/$defs/SystemMessage",
                  "UserMessage": "#/$defs/UserMessage"
               },
               "propertyName": "type"
            },
            "oneOf": [
               {
                  "$ref": "#/$defs/SystemMessage"
               },
               {
                  "$ref": "#/$defs/UserMessage"
               },
               {
                  "$ref": "#/$defs/AssistantMessage"
               },
               {
                  "$ref": "#/$defs/FunctionExecutionResultMessage"
               }
            ]
         },
         "title": "Context",
         "type": "array"
      }
   },
   "$defs": {
      "AssistantMessage": {
         "description": "Assistant message are sampled from the language model.",
         "properties": {
            "content": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "items": {
                        "$ref": "#/$defs/FunctionCall"
                     },
                     "type": "array"
                  }
               ],
               "title": "Content"
            },
            "thought": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Thought"
            },
            "source": {
               "title": "Source",
               "type": "string"
            },
            "type": {
               "const": "AssistantMessage",
               "default": "AssistantMessage",
               "title": "Type",
               "type": "string"
            }
         },
         "required": [
            "content",
            "source"
         ],
         "title": "AssistantMessage",
         "type": "object"
      },
      "FunctionCall": {
         "properties": {
            "id": {
               "title": "Id",
               "type": "string"
            },
            "arguments": {
               "title": "Arguments",
               "type": "string"
            },
            "name": {
               "title": "Name",
               "type": "string"
            }
         },
         "required": [
            "id",
            "arguments",
            "name"
         ],
         "title": "FunctionCall",
         "type": "object"
      },
      "FunctionExecutionResult": {
         "description": "Function execution result contains the output of a function call.",
         "properties": {
            "content": {
               "title": "Content",
               "type": "string"
            },
            "name": {
               "title": "Name",
               "type": "string"
            },
            "call_id": {
               "title": "Call Id",
               "type": "string"
            },
            "is_error": {
               "anyOf": [
                  {
                     "type": "boolean"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Is Error"
            }
         },
         "required": [
            "content",
            "name",
            "call_id"
         ],
         "title": "FunctionExecutionResult",
         "type": "object"
      },
      "FunctionExecutionResultMessage": {
         "description": "Function execution result message contains the output of multiple function calls.",
         "properties": {
            "content": {
               "items": {
                  "$ref": "#/$defs/FunctionExecutionResult"
               },
               "title": "Content",
               "type": "array"
            },
            "type": {
               "const": "FunctionExecutionResultMessage",
               "default": "FunctionExecutionResultMessage",
               "title": "Type",
               "type": "string"
            }
         },
         "required": [
            "content"
         ],
         "title": "FunctionExecutionResultMessage",
         "type": "object"
      },
      "SystemMessage": {
         "description": "System message contains instructions for the model coming from the developer.\n\n.. note::\n\n    Open AI is moving away from using 'system' role in favor of 'developer' role.\n    See `Model Spec <https://cdn.openai.com/spec/model-spec-2024-05-08.html#definitions>`_ for more details.\n    However, the 'system' role is still allowed in their API and will be automatically converted to 'developer' role\n    on the server side.\n    So, you can use `SystemMessage` for developer messages.",
         "properties": {
            "content": {
               "title": "Content",
               "type": "string"
            },
            "type": {
               "const": "SystemMessage",
               "default": "SystemMessage",
               "title": "Type",
               "type": "string"
            }
         },
         "required": [
            "content"
         ],
         "title": "SystemMessage",
         "type": "object"
      },
      "UserMessage": {
         "description": "User message contains input from end users, or a catch-all for data provided to the model.",
         "properties": {
            "content": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "items": {
                        "anyOf": [
                           {
                              "type": "string"
                           },
                           {}
                        ]
                     },
                     "type": "array"
                  }
               ],
               "title": "Content"
            },
            "source": {
               "title": "Source",
               "type": "string"
            },
            "type": {
               "const": "UserMessage",
               "default": "UserMessage",
               "title": "Type",
               "type": "string"
            }
         },
         "required": [
            "content",
            "source"
         ],
         "title": "UserMessage",
         "type": "object"
      }
   },
   "required": [
      "code",
      "context"
   ]
}

Felder:

• code (str)

• context (List[autogen_core.models._types.SystemMessage | autogen_core.models._types.UserMessage | autogen_core.models._types.AssistantMessage | autogen_core.models._types.FunctionExecutionResultMessage])

field code: str [Required]

field context: List[Annotated[SystemMessage | UserMessage | AssistantMessage | FunctionExecutionResultMessage, FieldInfo(annotation=NoneType, required=True, discriminator='type')]] [Required]

pydantic model ApprovalResponse

Bases: BaseModel

Antwort auf die Genehmigungsanfrage.

JSON-Schema anzeigen

{
   "title": "ApprovalResponse",
   "description": "Response to approval request.",
   "type": "object",
   "properties": {
      "approved": {
         "title": "Approved",
         "type": "boolean"
      },
      "reason": {
         "title": "Reason",
         "type": "string"
      }
   },
   "required": [
      "approved",
      "reason"
   ]
}

Felder:

• approved (bool)

• reason (str)

field approved: bool [Required]

field reason: str [Required]