Orchestrierung eines Multiagentensystems 🤖🤝🤖

In diesem Notizbuch werden wir eine Multi-Agenten-Webbrowser: ein agentenbasiertes System mit mehreren Agenten, die zusammenarbeiten, um Probleme über das Internet zu lösen!

Es handelt sich um eine einfache Hierarchie, die eine ManagedAgent Objekt, um den verwalteten Web-Suchagenten zu verpacken:

Kopiert

              +----------------+
              | Manager-Agent |
              +----------------+
                       |
        _______________|______________
       | |
  Code-Interpreter +--------------------------------+
       tool | Managed agent |
                     | +------------------+ |
                     | Web Search Agent | |
                     | +------------------+ |
                     | | | |
                     | Web-Suchwerkzeug | |
                     | Werkzeug für Webseitenbesuche |
                     +--------------------------------+

Richten wir dieses System ein.

Führen Sie die folgende Zeile aus, um die erforderlichen Abhängigkeiten zu installieren:

Kopiert

!pip install markdownify duckduckgo-search smolagents --upgrade -q

Melden wir uns an, um die HF Inference API aufzurufen:

Kopiert

von huggingface_hub importieren login

login()

⚡️ Unser Agent wird betrieben von Qwen/Qwen2.5-Coder-32B-Instruct mit HfApiModel Klasse, die die Inferenz-API von HF verwendet: Die Inferenz-API ermöglicht die schnelle und einfache Ausführung beliebiger OS-Modelle.

Anmerkung: Die Inference API enthält Modelle, die auf verschiedenen Kriterien basieren, und eingesetzte Modelle können ohne vorherige Ankündigung aktualisiert oder ersetzt werden. Erfahren Sie mehr darüber hier.

Kopiert

model_id = "Qwen/Qwen2.5-Coder-32B-Instruct"

🔍 Ein Web-Suchwerkzeug erstellen #

Für das Surfen im Internet können wir bereits unsere bereits vorhandenen DuckDuckGoSearchTool Tool, um eine Google-Suche zu ermöglichen.

Aber dann müssen wir auch in der Lage sein, die Seite zu sehen, die von der DuckDuckGoSearchTool. Um dies zu tun, könnten wir die in der Bibliothek integrierte VisitWebpageToolaber wir werden es noch einmal bauen, um zu sehen, wie es gemacht wird.

Erstellen wir also unser VisitWebpageTool Werkzeug von Grund auf mit markdownify.

Kopiert

re importieren
importiere Anfragen
from markdownify import markdownify
from requests.exceptions import RequestException
von smolagents importieren Werkzeug


@tool
def visit_webpage(url: str) -> str:
    """Besucht eine Webseite unter der angegebenen URL und gibt deren Inhalt als Markdown-String zurück.

    Args:
        url: Die URL der zu besuchenden Webseite.

    Rückgabe:
        Der Inhalt der Webseite, der in Markdown konvertiert wurde, oder eine Fehlermeldung, wenn die Anfrage fehlschlägt.
    """
    try:
        # Senden Sie eine GET-Anfrage an die URL
        response = requests.get(url)
        response.raise_for_status()  # Auslösen einer Ausnahme für schlechte Statuscodes

        # Konvertierung des HTML-Inhalts in Markdown
        markdown_content = markdownify(response.text).strip()

        # Mehrere Zeilenumbrüche entfernen
        markdown_content = re.sub(r"\n{3,}", "\n\n", markdown_content)

        return abschrift_inhalt

    except RequestException as e:
        return f "Fehler beim Abrufen der Webseite: {str(e)}"
    except Exception as e:
        return f "Ein unerwarteter Fehler ist aufgetreten: {str(e)}"

Ok, jetzt wollen wir unser Tool initialisieren und testen!

Kopiert

print(visit_webpage("https://en.wikipedia.org/wiki/Hugging_Face")[:500])

Unser Multiagentensystem aufbauen 🤖🤝🤖 #

Jetzt, wo wir alle Werkzeuge haben Suche und visit_webpagekönnen wir sie verwenden, um den Webagenten zu erstellen.

Welche Konfiguration soll für diesen Agenten gewählt werden?

• Das Surfen im Internet ist eine Aufgabe mit einer einzigen Zeitleiste, die keine parallelen Werkzeugaufrufe erfordert, so dass JSON-Werkzeugaufrufe dafür gut geeignet sind. Wir wählen daher eine JsonAgent.
• Da bei der Websuche manchmal viele Seiten durchsucht werden müssen, bevor die richtige Antwort gefunden wird, ziehen wir es vor, die Anzahl der max_steps bis 10.

Kopiert

von smolagents importieren (
    CodeAgent,
    ToolCallingAgent,
    HfApiModel,
    ManagedAgent,
    DuckDuckGoSearchTool,
    LiteLLMModel,
)

model = HfApiModel(model_id)

web_agent = ToolCallingAgent(
    tools=[DuckDuckGoSearchTool(), visit_webpage],
    model=model,
    max_steps=10,
)

Wir verpacken diesen Agenten dann in eine ManagedAgent die ihn für seinen Manager-Agenten aufrufbar macht.

Kopiert

managed_web_agent = ManagedAgent(
    agent=web_agent,
    name="Suche",
    description="Führt Websuchen für Sie durch. Geben Sie ihm Ihre Anfrage als Argument.",
)

Schließlich erstellen wir einen Manager-Agenten und übergeben ihm bei der Initialisierung unseren verwalteten Agenten in seiner verwaltete_Agenten Argument.

Da dieser Agent mit der Planung und dem Denken betraut ist, ist ein fortgeschrittenes Denken von Vorteil, so dass ein CodeAgent wird die beste Wahl sein.

Außerdem wollen wir eine Frage stellen, die das aktuelle Jahr betrifft und zusätzliche Datenberechnungen vornimmt: Fügen wir also hinzu additional_authorized_imports=["time", "numpy", "pandas"]für den Fall, dass der Agent diese Pakete benötigt.

Kopiert

manager_agent = CodeAgent(
    tools=[],
    model=model,
    managed_agents=[managed_web_agent],
    additional_authorized_imports=["time", "numpy", "pandas"],
)

Das war's schon! Jetzt lassen wir unser System laufen! Wir wählen eine Frage, die sowohl eine Berechnung als auch eine Recherche erfordert:

Kopiert

answer = manager_agent.run("Wenn die LLM-Ausbildung bis 2030 weiterhin im derzeitigen Rhythmus zunimmt, wie hoch wäre dann die elektrische Leistung in GW, die erforderlich wäre, um die größten Ausbildungsgänge bis 2030 zu betreiben? Was würde das im Vergleich zu einigen Ländern bedeuten? Bitte geben Sie eine Quelle für alle verwendeten Zahlen an.")

Wir erhalten diesen Bericht als Antwort:

Kopiert

Ausgehend von den aktuellen Wachstumsprognosen und Energieverbrauchsschätzungen würde eine weitere Zunahme der LLM-Ausbildungen im
bis zum Jahr 2030:

1. Die elektrische Energie, die benötigt wird, um die größten Ausbildungsgänge bis 2030 zu betreiben, würde etwa 303,74 GW betragen, was
was etwa 2.660.762 GWh/Jahr entspricht.

2. Vergleichen Sie dies mit dem Stromverbrauch der Länder:
   - Dies entspräche etwa 34% des gesamten Stromverbrauchs Chinas.
   - Es wäre mehr als der gesamte Stromverbrauch von Indien (184%), Russland (267%) und Japan (291%).
   - Es wäre fast das Neunfache des Stromverbrauchs von Ländern wie Italien oder Mexiko.

3. Quelle der Zahlen:
   - Die ursprüngliche Schätzung von 5 GW für künftige LLM-Ausbildung stammt von AWS-CEO Matt Garman.
   - Für die Wachstumsprognose wurde ein CAGR von 79,80% aus der Marktforschung von Springs verwendet.
   - Die Daten zum Stromverbrauch des Landes stammen von der U.S. Energy Information Administration, hauptsächlich für das Jahr
2021.

Es scheint, dass wir einige große Kraftwerke brauchen, wenn die Skalierungshypothese gilt auch weiterhin.

Unsere Agenten haben es geschafft, effizient an der Lösung der Aufgabe mitzuarbeiten! ✅

💡 Sie können diese Orchestrierung leicht auf mehrere Agenten erweitern: einer führt den Code aus, einer die Websuche, einer das Laden von Dateien...