Flux de travail multi-agent avec Llamaindex pour la recherche et l'écriture-IA-php.cn

Les agents du modèle de langue grand sont des outils puissants pour automatiser des tâches telles que la recherche, la génération de contenu et la révision de la qualité. Cependant, un seul agent ne peut souvent pas tout faire efficacement, surtout lorsque vous devez intégrer des ressources externes (comme les recherches Web) et plusieurs étapes spécialisées (par exemple, rédaction vs revues). Les workflows multi-agents vous permettent de diviser ces tâches entre les différents agents, chacun avec ses propres outils, contraintes et responsabilités. Dans cet article, nous allons examiner comment construire un système à trois agents - Researchagent, WriteAgent et ReviewAgent - où chaque agent gère une partie spécifique de la création d'un rapport historique concis sur Internet. Nous nous assurerons également que le système ne restera pas coincé dans une boucle de recherche, ce qui peut perdre du temps et des crédits.

Objectifs d'apprentissage

comprendre comment les workflows multi-agents améliorent l'automatisation des tâches avec LLMS.
Apprenez à construire un système à trois agents pour la recherche, la rédaction et la révision des tâches.
Implémentez les sauvegardes pour empêcher les boucles de recherche infinies dans les workflows automatisés.
Explorez l'intégration d'outils externes comme DuckDuckgo pour une récupération efficace des données.
Développer un flux de travail alimenté par LLM qui assure une génération de contenu structurée et de haute qualité.

Cet article a été publié dans le cadre du Data Science Blogathon.

Table des matières

Modèle de langue (LLM) - Openai GPT-4
Outils essentiels pour le flux de travail
Définition des agents AI pour l'exécution des tâches
Agent Workflow - COORDIATIN Attendez-vous
outils essentiels pour le flux de travail
Les outils sont des fonctions que les agents peuvent appeler pour effectuer des actions en dehors de leur propre modélisation linguistique. Les outils typiques incluent:

Recherche Web

###############################################################################
# 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")

Copier après la connexion

Fichiers de lecture / écriture

Définition des agents AI pour l'exécution des tâches
Chaque agent est une instance de functionagent . Les champs clés comprennent:

name et Description
System_Prompt : Informe l'agent sur son rôle et ses contraintes
llm : le modèle de langue utilisé
Outils : Quelles fonctions que l'agent peut appeler
can_handoff_to : Quel (s) agent (s) cet agent peut contrôler la main vers

Researchagent

Recherche sur le Web (jusqu'à une limite spécifiée des requêtes)
enregistre les résultats pertinents en tant que «notes»
Habile à l'agent suivant une fois que suffisamment d'informations sont collectées

writeAgent

compose le rapport dans Markdown, en utilisant toutes les notes que le recherche a collecté
Hands off à la revueAgent pour commentaires

revoiragent

examine le projet de contenu pour l'exactitude et l'exhaustivité
Si des modifications sont nécessaires, les mains contrôlent à l'écriture
Sinon, fournit l'approbation finale

###############################################################################
# 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")

Copier après la connexion

Fil de travail de l'agent - Exécution de la tâche de coordination

Un agentworkflow coordonne comment les messages et l'état se déplacent entre les agents. Lorsque l'utilisateur initie une demande (par exemple, «Écrivez-moi un rapport concis sur l'historique d'Internet…»), le workflow:

ResearchAgent reçoit l'invite de l'utilisateur et décide d'effectuer une recherche Web ou d'enregistrer quelques notes.
writeAgent utilise les notes pour créer une sortie structurée ou stylée (comme un document Markdown).
ReviewAgent vérifie la sortie finale et la renvoie pour la révision ou l'approuve.

Le flux de travail se termine une fois le contenu approuvé et qu'aucune autre modification n'est demandée.

construire le flux de travail

À cette étape, nous définissons le flux de travail de l'agent, qui comprend des agents de recherche, d'écriture et de révision. Le root_agent est défini sur la recherche_agent, ce qui signifie que le processus commence par la collecte de recherche. L'état initial contient des espaces réservés pour les notes de recherche, le contenu du contenu et le statut de revue.

###############################################################################
# 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."

Copier après la connexion

Exécutez le flux de travail

Le workflow est exécuté à l'aide d'une demande utilisateur, qui spécifie le sujet et les points clés à couvrir dans le rapport. La demande de cet exemple demande un rapport concis sur l'histoire d'Internet, y compris ses origines, le développement du World Wide Web et son évolution moderne. Le workflow traite cette demande en coordonnant les agents.

###############################################################################
# 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"]
)

Copier après la connexion

Stream Events for Debogging ou Observation

Pour surveiller l'exécution du workflow, nous diffusons des événements et imprimons les détails des activités d'agent. Cela nous permet de suivre quel agent fonctionne actuellement, d'afficher les sorties intermédiaires et d'inspecter les appels d'outils effectués par les agents. Les informations de débogage telles que l'utilisation et les réponses des outils sont affichées pour une meilleure visibilité.

###############################################################################
# 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")

Copier après la connexion

récupérer et imprimer le rapport final

Une fois le flux de travail terminé, nous extraisons l'état final, qui contient le rapport généré. Le contenu du rapport est imprimé, suivi de tout commentaire d'examen de l'agent de révision. Cela garantit que la sortie est complète et peut être affinée si nécessaire.

###############################################################################
# 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."

Copier après la connexion

Flux de travail multi-agent avec Llamaindex pour la recherche et l'écriture

Éviter une boucle de recherche infinie

Lorsque vous utilisez un outil de recherche Web, il est possible que le LLM soit «confus» et d'appeler à plusieurs reprises la fonction de recherche. Cela peut entraîner des coûts inutiles ou une consommation de temps. Pour éviter cela, nous utilisons deux mécanismes:

Hard Limitwe set max_search_calls = 2 , de sorte que l'outil de recherche ne peut être appelé que deux fois.
Détection en double, nous stockons les requêtes passées dans un ensemble ( Past_queries ) pour éviter de répéter la même recherche exactement plusieurs fois.

Si l'une ou l'autre condition est remplie (les recherches maximales ou une requête en double), notre fonction safe_duckduckgo_search renvoie un message en conserve au lieu d'effectuer une nouvelle recherche.

à quoi s'attendre?

ResearchAgent

reçoit la demande de l'utilisateur pour rédiger un rapport concis sur l'historique d'Internet.
effectue peut-être jusqu'à deux recherches distinctes de Duckduckgo (par exemple, «History of Internet» et «World Wide Web Tim Berners-Lee», etc.), puis appelle Record_Notes pour stocker un résumé.

writeAgent

lit les «Research_notes» du contexte partagé.
rédige un court rapport de marque.
Hands off au ReviewAgent.

revoiragent

évalue le contenu.
Si des modifications sont nécessaires, il peut ramener le contrôle à WriteAgent. Sinon, il approuve le rapport.

Le flux de travail se termine

La sortie finale est stockée dans final_state ["report_content"].

Conclusion

En divisant votre flux de travail en agents distincts pour Rechercher , Écriture , et Review , vous pouvez créer un système puissant et modulaire qui:

rassemble des informations pertinentes (de manière contrôlée, empêchant les recherches excessives)
produit des sorties structurées et de haute qualité
auto-cocher pour la précision et l'exhaustivité

L'intégration de DuckDuckgo utilisant Langchain propose une solution de recherche Web plug-and-play pour le flux de travail multi-agents sans nécessiter des clés API ou des informations d'identification spécialisées. Combiné avec des garanties intégrées (limites d'appel de recherche, détection en double), ce système est robuste, efficace et adapté à un large éventail de tâches de recherche et de génération de contenu.

Les plats clés

Les workflows multi-agents améliorent l'efficacité en attribuant des rôles spécialisés aux agents LLM.
L'utilisation d'outils externes comme DuckDuckgo améliore les capacités de recherche des agents LLM.
La mise en œuvre des contraintes, telles que les limites de recherche, empêche la consommation de ressources inutile.
Les flux de travail des agents coordonnés garantissent une génération de contenu structurée et de haute qualité.
Un mécanisme de transfert bien conçu aide à éviter les tâches redondantes et les boucles infinies.

Les questions fréquemment posées

Q1. Pourquoi utiliser plusieurs agents au lieu d'un seul agent tout usage?

a. La division des responsabilités entre les agents (recherche, écriture, révision) garantit que chaque étape est clairement définie et plus facile à gérer. Il réduit également la confusion dans la prise de décision du modèle et favorise les sorties structurées plus précises.

Q2. Comment limiter le nombre de recherches Web?

a. Dans le code, nous utilisons un compteur global (search_call_count) et une constante (max_search_calls = 2). Chaque fois que l'agent de recherche appelle Safe_DUCKDUCKGO_SEARCH, il vérifie si le compteur a atteint la limite. Si c'est le cas, il renvoie un message au lieu d'effectuer une autre recherche.

Q3. Et si l'agent répète la même requête plusieurs fois?

a. Nous maintenons un ensemble Python appelé Past_queries pour détecter les requêtes répétées. Si la requête est déjà dans cet ensemble, l'outil sautera effectuer la recherche réelle et renverra un court message, empêchant les requêtes en double de l'exécution.

Q4. Puis-je changer les invites pour adapter ce flux de travail pour un autre sujet ou style?

a. Absolument. Vous pouvez modifier System_Prompt de chaque agent pour adapter les instructions à votre domaine ou à votre style d'écriture souhaité. Par exemple, vous pouvez demander à l'écriture de produire une liste de points, un essai narratif ou un résumé technique.

Q5. Ai-je besoin de GPT-4, ou puis-je utiliser un autre modèle?

a. Vous pouvez échanger OpenAI (Model = ”GPT-4 ″) pour un autre modèle pris en charge par Llama-Index (par exemple, GPT-3.5, ou même un modèle local). L'architecture reste la même, bien que certains modèles puissent produire des sorties de différentes qualité.

Le média présenté dans cet article ne appartient pas à l'analyse vidhya et est utilisé à la discrétion de l'auteur.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!