autogen_ext.teams.magentic_one#

class MagenticOne(client: ChatCompletionClient, hil_mode: bool = False, input_func: Callable[[str], str] | Callable[[str, CancellationToken | None], Awaitable[str]] | None = None, code_executor: CodeExecutor | None = None, approval_func: Callable[[ApprovalRequest], ApprovalResponse] | Callable[[ApprovalRequest], Awaitable[ApprovalResponse]] | None = None)[Quelle]#

Bases: MagenticOneGroupChat

MagenticOne ist eine spezialisierte Gruppenchat-Klasse, die verschiedene Agenten wie FileSurfer, WebSurfer, Coder und Executor integriert, um komplexe Aufgaben zu lösen. Weitere Informationen über die Wissenschaft hinter Magentic-One finden Sie im vollständigen Blogbeitrag: Magentic-One: A Generalist Multi-Agent System for Solving Complex Tasks und den unten aufgeführten Referenzen.

Installation

pip install "autogen-ext[magentic-one]"
Parameter:

  • client (ChatCompletionClient) – Der Client, der für Modellinteraktionen verwendet wird.

  • hil_mode (bool) – Optional; Wenn auf True gesetzt, wird der UserProxyAgent zur Liste der Agenten hinzugefügt.

  • input_func (InputFuncType | None) – Optional; Funktion, die für Benutzereingaben im Human-in-the-Loop-Modus verwendet wird.

  • code_executor (CodeExecutor | None) – Optional; Zu verwendender Code-Executor. Wenn None, wird Docker verwendet, falls verfügbar, andernfalls ein lokaler Executor.

  • approval_func (ApprovalFuncType | None) – Optional; Funktion zur Genehmigung der Codeausführung vor dem Start. Wenn None, wird der Code ohne Genehmigung ausgeführt.

Warnung

Die Verwendung von Magentic-One beinhaltet die Interaktion mit einer digitalen Welt, die für Menschen konzipiert ist und inhärente Risiken birgt. Um diese Risiken zu minimieren, beachten Sie die folgenden Vorsichtsmaßnahmen:

  1. Container verwenden: Führen Sie alle Aufgaben in Docker-Containern aus, um die Agenten zu isolieren und direkte Systemangriffe zu verhindern.

  2. Virtuelle Umgebung: Verwenden Sie eine virtuelle Umgebung, um die Agenten auszuführen und zu verhindern, dass sie auf sensible Daten zugreifen.

  3. Protokolle überwachen: Überwachen Sie die Protokolle während und nach der Ausführung genau, um riskantes Verhalten zu erkennen und zu mindern.

  4. Menschliche Aufsicht: Führen Sie die Beispiele mit einem menschlichen Eingriff (Human in the Loop) aus, um die Agenten zu überwachen und unbeabsichtigte Folgen zu verhindern.

  5. Zugriff einschränken: Beschränken Sie den Zugriff der Agenten auf das Internet und andere Ressourcen, um unbefugte Handlungen zu verhindern.

  6. Daten sichern: Stellen Sie sicher, dass die Agenten keinen Zugriff auf sensible Daten oder Ressourcen haben, die kompromittiert werden könnten. Geben Sie keine sensiblen Informationen an die Agenten weiter.

Beachten Sie, dass Agenten gelegentlich riskante Aktionen durchführen können, wie z. B. die Rekrutierung von Menschen zur Hilfe oder die Annahme von Cookie-Vereinbarungen ohne menschliche Beteiligung. Stellen Sie immer sicher, dass Agenten überwacht werden und in einer kontrollierten Umgebung arbeiten, um unbeabsichtigte Folgen zu vermeiden. Seien Sie außerdem vorsichtig, da Magentic-One anfällig für Prompt-Injection-Angriffe von Webseiten sein kann.

Architektur

Magentic-One ist ein generalistisches Multi-Agenten-System zur Lösung von offenen, web- und dateibasierten Aufgaben in verschiedenen Domänen. Es stellt einen bedeutenden Schritt auf dem Weg zur Entwicklung von Agenten dar, die Aufgaben erledigen können, denen Menschen in ihrem beruflichen und privaten Leben begegnen.

Magentic-One basiert auf einer Multi-Agenten-Architektur, bei der ein führender Orchestrator-Agent für die High-Level-Planung, die Steuerung anderer Agenten und die Verfolgung des Aufgabenfortschritts verantwortlich ist. Der Orchestrator erstellt zunächst einen Plan zur Bewältigung der Aufgabe und sammelt benötigte Fakten und fundierte Vermutungen in einem Task Ledger, der geführt wird. Bei jedem Schritt seines Plans erstellt der Orchestrator einen Progress Ledger, in dem er den Fortschritt der Aufgabe reflektiert und prüft, ob die Aufgabe abgeschlossen ist. Wenn die Aufgabe noch nicht abgeschlossen ist, weist er einem der anderen Magentic-One-Agenten eine Unteraufgabe zu. Nachdem der zugewiesene Agent seine Unteraufgabe abgeschlossen hat, aktualisiert der Orchestrator den Progress Ledger und fährt auf diese Weise fort, bis die Aufgabe abgeschlossen ist. Wenn der Orchestrator feststellt, dass über mehrere Schritte hinweg kein Fortschritt erzielt wird, kann er den Task Ledger aktualisieren und einen neuen Plan erstellen.

Insgesamt besteht Magentic-One aus folgenden Agenten:

  • Orchestrator: Der führende Agent, der für die Aufgabendekomposition und -planung, die Steuerung anderer Agenten bei der Ausführung von Unteraufgaben, die Verfolgung des Gesamtfortschritts und die Einleitung von Korrekturmaßnahmen bei Bedarf zuständig ist.

  • WebSurfer: Ein LLM-basierter Agent, der erfahren im Befehligen und Verwalten des Zustands eines Chromium-basierten Webbrowsers ist. Er führt Aktionen im Browser aus und berichtet über den neuen Zustand der Webseite.

  • FileSurfer: Ein LLM-basierter Agent, der eine Markdown-basierte Dateivorschau-Anwendung steuert, um lokale Dateien der meisten Typen zu lesen. Er kann auch gängige Navigationsaufgaben wie das Auflisten von Verzeichnissen und das Navigieren durch eine Ordnerstruktur ausführen.

  • Coder: Ein LLM-basierter Agent, der auf das Schreiben von Code, die Analyse von Informationen, die von anderen Agenten gesammelt wurden, oder die Erstellung neuer Artefakte spezialisiert ist.

  • ComputerTerminal: Bietet dem Team Zugriff auf eine Konsolenshell, in der die Programme des Coder ausgeführt und neue Programmierbibliotheken installiert werden können.

Zusammen bilden die Agenten von Magentic-One den Orchestrator mit den Werkzeugen und Fähigkeiten, die zur Lösung einer breiten Palette von offenen Problemen benötigt werden, sowie der Fähigkeit, sich autonom an dynamische und sich ständig verändernde Web- und Dateisystemumgebungen anzupassen und darin zu agieren.

Examples

# Autonomously complete a coding task:
import asyncio
from autogen_ext.models.openai import OpenAIChatCompletionClient
from autogen_ext.teams.magentic_one import MagenticOne
from autogen_agentchat.ui import Console


async def example_usage():
    client = OpenAIChatCompletionClient(model="gpt-4o")
    m1 = MagenticOne(client=client)  # Uses DockerCommandLineCodeExecutor by default
    task = "Write a Python script to fetch data from an API."
    result = await Console(m1.run_stream(task=task))
    print(result)


if __name__ == "__main__":
    asyncio.run(example_usage())

# Enable human-in-the-loop mode with explicit Docker executor and code approval
import asyncio
from autogen_ext.models.openai import OpenAIChatCompletionClient
from autogen_ext.teams.magentic_one import MagenticOne
from autogen_ext.code_executors.docker import DockerCommandLineCodeExecutor
from autogen_agentchat.ui import Console
from autogen_agentchat.agents import ApprovalRequest, ApprovalResponse


def user_input_func(prompt: str) -> str:
    """Custom input function for user interaction."""
    return input(prompt)


def approval_func(request: ApprovalRequest) -> ApprovalResponse:
    """Simple approval function that requests user input."""
    print(f"Code to execute:\n{request.code}")
    user_input = input("Do you approve this code execution? (y/n): ").strip().lower()
    if user_input == 'y':
        return ApprovalResponse(approved=True, reason="User approved the code execution")
    else:
        return ApprovalResponse(approved=False, reason="User denied the code execution")


async def example_usage_hil():
    client = OpenAIChatCompletionClient(model="gpt-4o")
    # Explicitly specify Docker code executor for better security
    async with DockerCommandLineCodeExecutor() as code_executor:
        m1 = MagenticOne(
            client=client,
            hil_mode=True,
            input_func=user_input_func,
            code_executor=code_executor,
            approval_func=approval_func
        )
        task = "Write a Python script to fetch data from an API."
        result = await Console(m1.run_stream(task=task))
        print(result)


if __name__ == "__main__":
    asyncio.run(example_usage_hil())

# Enable code execution approval without human-in-the-loop mode
import asyncio
from autogen_ext.models.openai import OpenAIChatCompletionClient
from autogen_ext.teams.magentic_one import MagenticOne
from autogen_ext.code_executors.docker import DockerCommandLineCodeExecutor
from autogen_agentchat.ui import Console
from autogen_agentchat.agents import ApprovalRequest, ApprovalResponse


def approval_func(request: ApprovalRequest) -> ApprovalResponse:
    """Simple approval function that requests user input."""
    print(f"Code to execute:\n{request.code}")
    user_input = input("Do you approve this code execution? (y/n): ").strip().lower()
    if user_input == 'y':
        return ApprovalResponse(approved=True, reason="User approved the code execution")
    else:
        return ApprovalResponse(approved=False, reason="User denied the code execution")


async def example_usage_with_approval():
    client = OpenAIChatCompletionClient(model="gpt-4o")
    # Use approval_func for code approval only (hil_mode=False)
    async with DockerCommandLineCodeExecutor() as code_executor:
        m1 = MagenticOne(
            client=client,
            hil_mode=False,  # No human-in-the-loop for general conversation
            code_executor=code_executor,
            approval_func=approval_func  # But still ask for code execution approval
        )
        task = "Write a Python script to fetch data from an API."
        result = await Console(m1.run_stream(task=task))
        print(result)


if __name__ == "__main__":
    asyncio.run(example_usage_with_approval())

Referenzen

@article{fourney2024magentic,
    title={Magentic-one: A generalist multi-agent system for solving complex tasks},
    author={Fourney, Adam and Bansal, Gagan and Mozannar, Hussein and Tan, Cheng and Salinas, Eduardo and Niedtner, Friederike and Proebsting, Grace and Bassman, Griffin and Gerrits, Jack and Alber, Jacob and others},
    journal={arXiv preprint arXiv:2411.04468},
    year={2024},
    url={https://arxiv.org/abs/2411.04468}
}