Schnellstart

Hinweis

Siehe hier für Installationsanweisungen.

Bevor wir uns mit den Kern-APIs beschäftigen, beginnen wir mit einem einfachen Beispiel von zwei Agenten, die von 10 auf 1 herunterzählen.

Zuerst definieren wir die Agentenklassen und ihre jeweiligen Prozeduren zur Nachrichtenverarbeitung. Wir erstellen zwei Agentenklassen: Modifier und Checker. Der Modifier-Agent modifiziert eine gegebene Zahl und der Check-Agent prüft den Wert gegen eine Bedingung. Wir erstellen auch eine Message-Datenklasse, die die zwischen den Agenten übergebenen Nachrichten definiert.

from dataclasses import dataclass
from typing import Callable

from autogen_core import DefaultTopicId, MessageContext, RoutedAgent, default_subscription, message_handler


@dataclass
class Message:
    content: int


@default_subscription
class Modifier(RoutedAgent):
    def __init__(self, modify_val: Callable[[int], int]) -> None:
        super().__init__("A modifier agent.")
        self._modify_val = modify_val

    @message_handler
    async def handle_message(self, message: Message, ctx: MessageContext) -> None:
        val = self._modify_val(message.content)
        print(f"{'-'*80}\nModifier:\nModified {message.content} to {val}")
        await self.publish_message(Message(content=val), DefaultTopicId())  # type: ignore


@default_subscription
class Checker(RoutedAgent):
    def __init__(self, run_until: Callable[[int], bool]) -> None:
        super().__init__("A checker agent.")
        self._run_until = run_until

    @message_handler
    async def handle_message(self, message: Message, ctx: MessageContext) -> None:
        if not self._run_until(message.content):
            print(f"{'-'*80}\nChecker:\n{message.content} passed the check, continue.")
            await self.publish_message(Message(content=message.content), DefaultTopicId())
        else:
            print(f"{'-'*80}\nChecker:\n{message.content} failed the check, stopping.")

Wie Sie vielleicht schon bemerkt haben, ist die Logik der Agenten, egal ob sie ein Modell oder einen Code-Executor verwenden, vollständig von der Art und Weise entkoppelt, wie Nachrichten zugestellt werden. Das ist die Kernidee: Das Framework stellt eine Kommunikationsinfrastruktur bereit, und die Agenten sind für ihre eigene Logik verantwortlich. Wir nennen die Kommunikationsinfrastruktur eine Agentenlaufzeit.

Die Agentenlaufzeit ist ein Schlüsselkonzept dieses Frameworks. Neben der Zustellung von Nachrichten verwaltet sie auch den Lebenszyklus der Agenten. Die Erstellung von Agenten wird also von der Laufzeit gehandhabt.

Der folgende Code zeigt, wie Agenten mit SingleThreadedAgentRuntime, einer lokalen, eingebetteten Implementierung der Agentenlaufzeit, registriert und ausgeführt werden.

Hinweis

Wenn Sie VSCode oder einen anderen Editor verwenden, denken Sie daran, asyncio zu importieren und den Code mit async def main() -> None: zu umschließen und den Code mit der Funktion asyncio.run(main()) auszuführen.

from autogen_core import AgentId, SingleThreadedAgentRuntime

# Create a local embedded runtime.
runtime = SingleThreadedAgentRuntime()

# Register the modifier and checker agents by providing
# their agent types, the factory functions for creating instance and subscriptions.
await Modifier.register(
    runtime,
    "modifier",
    # Modify the value by subtracting 1
    lambda: Modifier(modify_val=lambda x: x - 1),
)

await Checker.register(
    runtime,
    "checker",
    # Run until the value is less than or equal to 1
    lambda: Checker(run_until=lambda x: x <= 1),
)

# Start the runtime and send a direct message to the checker.
runtime.start()
await runtime.send_message(Message(10), AgentId("checker", "default"))
await runtime.stop_when_idle()

--------------------------------------------------------------------------------
Checker:
10 passed the check, continue.
--------------------------------------------------------------------------------
Modifier:
Modified 10 to 9
--------------------------------------------------------------------------------
Checker:
9 passed the check, continue.
--------------------------------------------------------------------------------
Modifier:
Modified 9 to 8
--------------------------------------------------------------------------------
Checker:
8 passed the check, continue.
--------------------------------------------------------------------------------
Modifier:
Modified 8 to 7
--------------------------------------------------------------------------------
Checker:
7 passed the check, continue.
--------------------------------------------------------------------------------
Modifier:
Modified 7 to 6
--------------------------------------------------------------------------------
Checker:
6 passed the check, continue.
--------------------------------------------------------------------------------
Modifier:
Modified 6 to 5
--------------------------------------------------------------------------------
Checker:
5 passed the check, continue.
--------------------------------------------------------------------------------
Modifier:
Modified 5 to 4
--------------------------------------------------------------------------------
Checker:
4 passed the check, continue.
--------------------------------------------------------------------------------
Modifier:
Modified 4 to 3
--------------------------------------------------------------------------------
Checker:
3 passed the check, continue.
--------------------------------------------------------------------------------
Modifier:
Modified 3 to 2
--------------------------------------------------------------------------------
Checker:
2 passed the check, continue.
--------------------------------------------------------------------------------
Modifier:
Modified 2 to 1
--------------------------------------------------------------------------------
Checker:
1 failed the check, stopping.

Anhand der Ausgabe des Agenten können wir sehen, dass der Wert erfolgreich von 10 auf 1 dekrementiert wurde, wie die Bedingungen des Modifikators und Prüfers vorgeben.

AutoGen unterstützt auch eine verteilte Agentenlaufzeit, die Agenten hosten kann, die auf verschiedenen Prozessen oder Maschinen mit unterschiedlichen Identitäten, Sprachen und Abhängigkeiten laufen.

Um zu erfahren, wie Sie die Agentenlaufzeit, die Kommunikation, die Nachrichtenverarbeitung und das Abonnement nutzen können, lesen Sie bitte die Abschnitte nach dieser Schnellstart-Anleitung weiter.