Multi-Agent-Workflow mit Llamaindex für Forschung und Schreiben

großsprachige Modellagenten sind leistungsstarke Tools zur Automatisierung von Aufgaben wie Suche, Inhaltsgenerierung und Qualitätsüberprüfung. Ein einzelner Agent kann jedoch häufig nicht alles effizient tun, insbesondere wenn Sie externe Ressourcen (wie Websuche) und mehrere spezielle Schritte (z. B. Ausarbeitung vs. Überprüfung) integrieren müssen. Mit Multi-Agent-Workflows können Sie diese Aufgaben unter verschiedenen Agenten teilen, die jeweils eigene Werkzeuge, Einschränkungen und Verantwortlichkeiten haben. In diesem Artikel werden wir uns untersuchen, wie ein System mit drei Agenten erstellt wird-Researchagent, WriteAgent und ReviewAgent-, bei dem jeder Agent einen bestimmten Teil der Erstellung eines präzisen historischen Berichts über das Internet erstellt. Wir werden auch sicherstellen, dass das System in einer Suchschleife nicht stecken bleibt, die Zeit und Credits verschwenden kann.

Lernziele

Verstehen Sie, wie Multi-Agent-Workflows die Aufgabenautomatisierung mit LLMs verbessern.
Lernen Sie, ein Drei-Agent-System für Forschungs-, Schreiben und Überprüfungsaufgaben zu erstellen.
implementieren Sie Sicherheitsvorkehrungen, um unendliche Suchschleifen in automatisierten Workflows zu verhindern.
Erforschen Sie die Integration externer Tools wie Duckduckgo für ein effizientes Datenabruf.
Entwickeln Sie einen LLM-Workflow, der strukturierte und qualitativ hochwertige Inhaltsgenerierung gewährleistet.

Dieser Artikel wurde als Teil des Data Science -Blogathon veröffentlicht.

Inhaltsverzeichnis

Sprachmodell (LLM)-OpenAI GPT-4
Wesentliche Tools für den Workflow
Definieren von AI-Agenten für Aufgabenausführung
Agent-Workflow-Koordinierende Aufgabenausführung
einen Infinite-Loop-Loop-Loop-Loop-Loop-Loop-Loop-Loop-Loop-Loop-Loop-Loop-Loop. Erwarten Sie?

Sprachmodell (LLM)-OpenAI GPT-4

Wir werden OpenAI (model = ”gpt-4o”) von Lama-Index verwenden. Sie können dies mit einem anderen LLM austauschen, wenn Sie es vorziehen, aber GPT-4 ist normalerweise eine starke Wahl für Multi-Step-Argumentationsaufgaben.

###############################################################################
# 1. INSTALLATION
###############################################################################
# Make sure you have the following installed:
#   pip install llama-index langchain duckduckgo-search

###############################################################################
# 2. IMPORTS
###############################################################################
%pip install llama-index langchain duckduckgo-search

from llama_index.llms.openai import OpenAI

# For DuckDuckGo search via LangChain
from langchain.utilities import DuckDuckGoSearchAPIWrapper

# llama-index workflow classes
from llama_index.core.workflow import Context
from llama_index.core.agent.workflow import (
    FunctionAgent,
    AgentWorkflow,
    AgentInput,
    AgentOutput,
    ToolCall,
    ToolCallResult,
    AgentStream
)

import asyncio

###############################################################################
# 3. CREATE LLM
###############################################################################
# Replace "sk-..." with your actual OpenAI API key
llm = OpenAI(model="gpt-4", api_key="OPENAI_API_KEY")

Wesentliche Werkzeuge für den Workflow

Tools sind Funktionen, die Agenten anrufen können, um Aktionen außerhalb ihrer eigenen Sprachmodellierung auszuführen. Typische Werkzeuge sind:

• Websuche
• Lesen/Schreiben von Dateien
• Mathematikrechner
• APIs für externe Dienste

In unserem Beispiel ist das Schlüsselwerkzeug DuckDuckGoSearch, das Langchains DuckDuckGoSearchapiWrapper unter der Motorhaube verwendet. Wir haben auch Helfer -Tools, um Notizen aufzuzeichnen, einen Bericht zu schreiben und ihn zu überprüfen.

###############################################################################
# 4. DEFINE DUCKDUCKGO SEARCH TOOL WITH SAFEGUARDS
###############################################################################
# We wrap LangChain's DuckDuckGoSearchAPIWrapper with our own logic
# to prevent repeated or excessive searches.

duckduckgo = DuckDuckGoSearchAPIWrapper()

MAX_SEARCH_CALLS = 2
search_call_count = 0
past_queries = set()

async def safe_duckduckgo_search(query: str) -> str:
    """
    A DuckDuckGo-based search function that:
      1) Prevents more than MAX_SEARCH_CALLS total searches.
      2) Skips duplicate queries.
    """
    global search_call_count, past_queries

    # Check for duplicate queries
    if query in past_queries:
        return f"Already searched for '{query}'. Avoiding duplicate search."

    # Check if we've reached the max search calls
    if search_call_count >= MAX_SEARCH_CALLS:
        return "Search limit reached, no more searches allowed."

    # Otherwise, perform the search
    search_call_count += 1
    past_queries.add(query)

    # DuckDuckGoSearchAPIWrapper.run(...) is synchronous, but we have an async signature
    result = duckduckgo.run(query)
    return str(result)
    
###############################################################################
# 5. OTHER TOOL FUNCTIONS: record_notes, write_report, review_report
###############################################################################
async def record_notes(ctx: Context, notes: str, notes_title: str) -> str:
    """Store research notes under a given title in the shared context."""
    current_state = await ctx.get("state")
    if "research_notes" not in current_state:
        current_state["research_notes"] = {}
    current_state["research_notes"][notes_title] = notes
    await ctx.set("state", current_state)
    return "Notes recorded."

async def write_report(ctx: Context, report_content: str) -> str:
    """Write a report in markdown, storing it in the shared context."""
    current_state = await ctx.get("state")
    current_state["report_content"] = report_content
    await ctx.set("state", current_state)
    return "Report written."

async def review_report(ctx: Context, review: str) -> str:
    """Review the report and store feedback in the shared context."""
    current_state = await ctx.get("state")
    current_state["review"] = review
    await ctx.set("state", current_state)
    return "Report reviewed."    

AI -Agenten für die Aufgabenausführung

definieren

Jeder Agent ist eine Instanz von functionagent . Zu den wichtigsten Feldern gehören:

• Name und Beschreibung
• system_prompt : weist den Agenten über seine Rolle und seine Einschränkungen
an
• llm : Das verwendete Sprachmodell
• Tools : Welche Funktionen, die der Agent
aufruft
• can_handoff_to : Welcher Agent kann diese Agent über
übergeben können

Researchagent

• sucht das Web (bis zu einer bestimmten Abfragestelle)
• speichert relevante Erkenntnisse als „Notizen“
• Übergänge zum nächsten Agenten, sobald genügend Informationen gesammelt wurden

writeAgent

• komponiert den Bericht in Markdown mit den Anmerkungen, die der Forschungsagent
gesammelt hat
• Übergänge zum Reviewagent für Feedback

reviewagent

• Überprüft den Entwurfsinhalt für Korrektheit und Vollständigkeit
Wenn Änderungen benötigt werden, kontrollieren die Hände zurück zum WriteAgent
Ansonsten liefert die endgültige Genehmigung

###############################################################################
# 1. INSTALLATION
###############################################################################
# Make sure you have the following installed:
#   pip install llama-index langchain duckduckgo-search

###############################################################################
# 2. IMPORTS
###############################################################################
%pip install llama-index langchain duckduckgo-search

from llama_index.llms.openai import OpenAI

# For DuckDuckGo search via LangChain
from langchain.utilities import DuckDuckGoSearchAPIWrapper

# llama-index workflow classes
from llama_index.core.workflow import Context
from llama_index.core.agent.workflow import (
    FunctionAgent,
    AgentWorkflow,
    AgentInput,
    AgentOutput,
    ToolCall,
    ToolCallResult,
    AgentStream
)

import asyncio

###############################################################################
# 3. CREATE LLM
###############################################################################
# Replace "sk-..." with your actual OpenAI API key
llm = OpenAI(model="gpt-4", api_key="OPENAI_API_KEY")

Agent Workflow - Koordinierende Aufgabenausführung

Ein Agentworkflow koordiniert, wie sich Nachrichten und der Zustand zwischen Agenten bewegen. Wenn der Benutzer eine Anfrage initiiert (z. B. „Schreiben Sie mir einen präzisen Bericht über die Geschichte des Internets…“), der Workflow:

• researchAgent
empfängt die Benutzeraufforderung und entscheidet, ob eine Websuche durchgeführt oder einige Notizen aufgezeichnet werden sollen.
• writeAgent
Verwendet die Notizen, um eine strukturierte oder gestylte Ausgabe zu erstellen (wie ein Markdown -Dokument).
• prüfungsagent
prüft die endgültige Ausgabe und sendet sie entweder für Revision zurück oder genehmigt sie.

Der Workflow endet, sobald der Inhalt genehmigt wurde und keine weiteren Änderungen angefordert werden.

Erstellen Sie den Workflow

In diesem Schritt definieren wir den Agent -Workflow, der Forschungs-, Schreib- und Überprüfungsagenten umfasst. Der Root_agent ist auf den Research_agent eingestellt, was bedeutet, dass der Prozess mit dem Sammeln von Forschung beginnt. Der Anfangszustand enthält Platzhalter für Forschungsnotizen, Inhalte und Überprüfungsstatus.

###############################################################################
# 4. DEFINE DUCKDUCKGO SEARCH TOOL WITH SAFEGUARDS
###############################################################################
# We wrap LangChain's DuckDuckGoSearchAPIWrapper with our own logic
# to prevent repeated or excessive searches.

duckduckgo = DuckDuckGoSearchAPIWrapper()

MAX_SEARCH_CALLS = 2
search_call_count = 0
past_queries = set()

async def safe_duckduckgo_search(query: str) -> str:
    """
    A DuckDuckGo-based search function that:
      1) Prevents more than MAX_SEARCH_CALLS total searches.
      2) Skips duplicate queries.
    """
    global search_call_count, past_queries

    # Check for duplicate queries
    if query in past_queries:
        return f"Already searched for '{query}'. Avoiding duplicate search."

    # Check if we've reached the max search calls
    if search_call_count >= MAX_SEARCH_CALLS:
        return "Search limit reached, no more searches allowed."

    # Otherwise, perform the search
    search_call_count += 1
    past_queries.add(query)

    # DuckDuckGoSearchAPIWrapper.run(...) is synchronous, but we have an async signature
    result = duckduckgo.run(query)
    return str(result)
    
###############################################################################
# 5. OTHER TOOL FUNCTIONS: record_notes, write_report, review_report
###############################################################################
async def record_notes(ctx: Context, notes: str, notes_title: str) -> str:
    """Store research notes under a given title in the shared context."""
    current_state = await ctx.get("state")
    if "research_notes" not in current_state:
        current_state["research_notes"] = {}
    current_state["research_notes"][notes_title] = notes
    await ctx.set("state", current_state)
    return "Notes recorded."

async def write_report(ctx: Context, report_content: str) -> str:
    """Write a report in markdown, storing it in the shared context."""
    current_state = await ctx.get("state")
    current_state["report_content"] = report_content
    await ctx.set("state", current_state)
    return "Report written."

async def review_report(ctx: Context, review: str) -> str:
    """Review the report and store feedback in the shared context."""
    current_state = await ctx.get("state")
    current_state["review"] = review
    await ctx.set("state", current_state)
    return "Report reviewed."    

Führen Sie den Workflow

aus

Der Workflow wird unter Verwendung einer Benutzeranforderung ausgeführt, wodurch das Thema und die wichtigsten Punkte angegeben werden, die im Bericht behandelt werden sollen. Die Anfrage in diesem Beispiel bittet um einen kurzen Bericht über die Geschichte des Internets, einschließlich seiner Herkunft, der Entwicklung des World Wide Web und seiner modernen Entwicklung. Der Workflow verarbeitet diese Anfrage durch Koordination der Agenten.

###############################################################################
# 6. DEFINE AGENTS
###############################################################################
# We have three agents with distinct responsibilities:
# 1. ResearchAgent  - uses DuckDuckGo to gather info (max 2 searches).
# 2. WriteAgent     - composes the final report.
# 3. ReviewAgent    - reviews the final report.

research_agent = FunctionAgent(
    name="ResearchAgent",
    description=(
        "A research agent that searches the web using DuckDuckGo. "
        "It must not exceed 2 searches total, and must avoid repeating the same query. "
        "Once sufficient information is collected, it should hand off to the WriteAgent."
    ),
    system_prompt=(
        "You are the ResearchAgent. Your goal is to gather sufficient information on the topic. "
        "Only perform at most 2 distinct searches. If you have enough info or have reached 2 searches, "
        "handoff to the next agent. Avoid infinite loops!"
    ),
    llm=llm,
    tools=[
        safe_duckduckgo_search,  # Our DuckDuckGo-based search function
        record_notes
    ],
    can_handoff_to=["WriteAgent"]
)

write_agent = FunctionAgent(
    name="WriteAgent",
    description=(
        "Writes a markdown report based on the research notes. "
        "Then hands off to the ReviewAgent for feedback."
    ),
    system_prompt=(
        "You are the WriteAgent. Draft a structured markdown report based on the notes. "
        "After writing, hand off to the ReviewAgent."
    ),
    llm=llm,
    tools=[write_report],
    can_handoff_to=["ReviewAgent", "ResearchAgent"]
)

review_agent = FunctionAgent(
    name="ReviewAgent",
    description=(
        "Reviews the final report for correctness. Approves or requests changes."
    ),
    system_prompt=(
        "You are the ReviewAgent. Read the report, provide feedback, and either approve "
        "or request revisions. If revisions are needed, handoff to WriteAgent."
    ),
    llm=llm,
    tools=[review_report],
    can_handoff_to=["WriteAgent"]
)

Stream -Ereignisse zum Debuggen oder Beobachtung

Um die Ausführung des Workflows zu überwachen, streamen wir Ereignisse und drucken Details zu Agentenaktivitäten. Auf diese Weise können wir nachverfolgen, welcher Agent derzeit funktioniert, Zwischenausgaben anzeigen und Toolaufrufe von den Agenten inspizieren. Debugging -Informationen wie die Verwendung von Werkzeugen und Antworten werden für eine bessere Sichtbarkeit angezeigt.

###############################################################################
# 1. INSTALLATION
###############################################################################
# Make sure you have the following installed:
#   pip install llama-index langchain duckduckgo-search

###############################################################################
# 2. IMPORTS
###############################################################################
%pip install llama-index langchain duckduckgo-search

from llama_index.llms.openai import OpenAI

# For DuckDuckGo search via LangChain
from langchain.utilities import DuckDuckGoSearchAPIWrapper

# llama-index workflow classes
from llama_index.core.workflow import Context
from llama_index.core.agent.workflow import (
    FunctionAgent,
    AgentWorkflow,
    AgentInput,
    AgentOutput,
    ToolCall,
    ToolCallResult,
    AgentStream
)

import asyncio

###############################################################################
# 3. CREATE LLM
###############################################################################
# Replace "sk-..." with your actual OpenAI API key
llm = OpenAI(model="gpt-4", api_key="OPENAI_API_KEY")

Abrufen und drucken Sie den Abschlussbericht

Sobald der Workflow abgeschlossen ist, extrahieren wir den endgültigen Zustand, der den generierten Bericht enthält. Der Bericht des Berichts wird gedruckt, gefolgt von einem Überprüfungsfeedback des Überprüfungsagenten. Dies stellt sicher, dass die Ausgabe abgeschlossen ist und bei Bedarf weiter verfeinert werden kann.

###############################################################################
# 4. DEFINE DUCKDUCKGO SEARCH TOOL WITH SAFEGUARDS
###############################################################################
# We wrap LangChain's DuckDuckGoSearchAPIWrapper with our own logic
# to prevent repeated or excessive searches.

duckduckgo = DuckDuckGoSearchAPIWrapper()

MAX_SEARCH_CALLS = 2
search_call_count = 0
past_queries = set()

async def safe_duckduckgo_search(query: str) -> str:
    """
    A DuckDuckGo-based search function that:
      1) Prevents more than MAX_SEARCH_CALLS total searches.
      2) Skips duplicate queries.
    """
    global search_call_count, past_queries

    # Check for duplicate queries
    if query in past_queries:
        return f"Already searched for '{query}'. Avoiding duplicate search."

    # Check if we've reached the max search calls
    if search_call_count >= MAX_SEARCH_CALLS:
        return "Search limit reached, no more searches allowed."

    # Otherwise, perform the search
    search_call_count += 1
    past_queries.add(query)

    # DuckDuckGoSearchAPIWrapper.run(...) is synchronous, but we have an async signature
    result = duckduckgo.run(query)
    return str(result)
    
###############################################################################
# 5. OTHER TOOL FUNCTIONS: record_notes, write_report, review_report
###############################################################################
async def record_notes(ctx: Context, notes: str, notes_title: str) -> str:
    """Store research notes under a given title in the shared context."""
    current_state = await ctx.get("state")
    if "research_notes" not in current_state:
        current_state["research_notes"] = {}
    current_state["research_notes"][notes_title] = notes
    await ctx.set("state", current_state)
    return "Notes recorded."

async def write_report(ctx: Context, report_content: str) -> str:
    """Write a report in markdown, storing it in the shared context."""
    current_state = await ctx.get("state")
    current_state["report_content"] = report_content
    await ctx.set("state", current_state)
    return "Report written."

async def review_report(ctx: Context, review: str) -> str:
    """Review the report and store feedback in the shared context."""
    current_state = await ctx.get("state")
    current_state["review"] = review
    await ctx.set("state", current_state)
    return "Report reviewed."    

Vermeiden Sie eine unendliche Suchschleife

Bei Verwendung eines Web -Such -Tools können LLM „verwirrt“ werden und die Suchfunktion wiederholt aufrufen. Dies kann zu unnötigen Kosten oder Zeitverbrauch führen. Um dies zu verhindern, verwenden wir zwei Mechanismen:

• hartes Grenzwert set max_search_calls = 2 , sodass das Forschungstool nur zweimal aufgerufen werden kann.
• doppelte Erkennung Wir speichern frühere Abfragen in einem Satz ( past_queries ), um das Wiederholen der genauen Suche mehrmals zu vermeiden.

Wenn eine Bedingung erfüllt ist (die maximale Suchanfragen oder eine doppelte Abfrage), gibt unsere Funktion safe_duckduckgo_search eine Konservennachricht zurück, anstatt eine neue Suche durchzuführen.

Was zu erwarten?

researchagent

• empfängt die Benutzeranforderung, einen präzisen Bericht über die Geschichte des Internets zu schreiben.
• führt möglicherweise bis zu zwei verschiedene Entenduckgo-Suchvorgänge (z.

writeAgent

liest die "Research_notes" aus dem gemeinsamen Kontext.
Entworfen einen kurzen Markdown -Bericht.
Übergänge zum Reviewagent.

reviewAgent

bewertet den Inhalt.
Wenn Änderungen benötigt werden, kann es die Kontrolle über WriteAgent zurückgeben. Andernfalls genehmigt es den Bericht.

Workflow endet

Die endgültige Ausgabe wird in

Final_state ["Report_Content"] gespeichert.

Schlussfolgerung

, indem Sie Ihren Workflow in verschiedene Agenten für

suchen , schreiben und Bewertung , können Sie ein leistungsstarkes, modulares System erstellen, das:

sammelt relevante Informationen (auf kontrollierte Weise, die übermäßige Suchvorgänge verhindern)
produziert strukturierte hochwertige Ausgänge
Selbstprüfungen für Genauigkeit und Vollständigkeit

Die DuckDuckgo-Integration mit Langchain bietet eine Plug-and-Play-Web-Suchlösung für Multi-Agent-Workflow, ohne spezialisierte API-Schlüssel oder Anmeldeinformationen zu erfordern. In Kombination mit integrierten Schutzmaßnahmen (Suchanrufgrenzen, doppelte Erkennung) ist dieses System robust, effizient und geeignet für eine Vielzahl von Forschungs- und Generationspflichten.

Key Takeaways

• Multi-Agent-Workflows verbessern die Effizienz, indem sie LLM-Agenten spezielle Rollen zuweisen.
• Verwenden externer Tools wie DuckDuckgo verbessert die Forschungsfähigkeiten von LLM -Agenten.
• Implementierung von Einschränkungen wie Suchgrenzen verhindert unnötigen Ressourcenverbrauch.
• koordinierte Agenten-Workflows sorgen für eine strukturierte Erzeugung von hochwertigen Inhalten.
• Ein gut gestalteter Handoff-Mechanismus hilft, redundante Aufgaben und unendliche Schleifen zu vermeiden.

häufig gestellte Fragen

Q1. Warum sollten Sie mehrere Agenten anstelle eines einzelnen Allzweck-Agenten verwenden?

a. Die Aufteilung der Verantwortlichkeiten zwischen Agenten (Forschung, Schreiben, Überprüfung) stellt sicher, dass jeder Schritt klar definiert und leichter zu verwalten ist. Es reduziert auch die Verwirrung in der Entscheidungsfindung des Modells und fördert genauere, strukturierte Ausgänge.

Q2. Wie begrüße ich die Anzahl der Websuche?

a. Im Code verwenden wir einen globalen Zähler (Search_call_count) und eine Konstante (max_search_calls = 2). Immer wenn der Suchagent SAFE_DUCKDUCKGO_SEARCH anruft, prüft er, ob der Zähler das Limit erreicht hat. In diesem Fall wird eine Nachricht zurückgegeben, anstatt eine weitere Suche durchzuführen.

Q3. Was ist, wenn der Agent die gleiche Abfrage mehrmals wiederholt?

a. Wir führen ein Python -Set mit dem Namen Past_queries, um wiederholte Abfragen zu erkennen. Wenn sich die Abfrage bereits in diesem Satz befindet, überspringt das Tool die tatsächliche Suche und gibt eine Kurznachricht zurück, wodurch doppelte Abfragen ausgeführt werden.

Q4. Kann ich die Eingabeaufforderungen ändern, diesen Workflow für ein anderes Thema oder einen anderen Stil anzupassen?

a. Absolut. Sie können das System_Prompt jedes Agenten so bearbeiten, dass Anweisungen auf die gewünschte Domain oder den gewünschten Schreibstil angepasst werden. Zum Beispiel könnten Sie das Schreiben anweisen, eine Kugelspitzeliste, einen narrativen Aufsatz oder eine technische Zusammenfassung zu erstellen.

Q5. Benötige ich GPT-4 oder kann ich ein anderes Modell verwenden?

a. Sie können OpenAI (modell = ”GPT-4 ″) gegen ein von LLAMA-Index (z. B. GPT-3,5 oder sogar ein lokales Modell) unterstütztes Modell austauschen. Die Architektur bleibt gleich, obwohl einige Modelle Ausgaben in unterschiedlicher Qualität erzeugen können.

Die in diesem Artikel gezeigten Medien sind nicht im Besitz von Analytics Vidhya und wird nach Ermessen des Autors verwendet.

Das obige ist der detaillierte Inhalt vonMulti-Agent-Workflow mit Llamaindex für Forschung und Schreiben. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!