Context Engineering — Section 9 : Orchestration & Agents

La Boucle Agentique : Le Framework ReAct

Le framework **ReAct (Reason + Act)** est le patron de conception fondamental de la plupart des agents modernes. L'agent opère dans une boucle où il alterne entre la pensée et l'action.

La Gestion des Outils (Tools)

Les outils sont les "mains" de l'agent. Leur qualité et leur description sont critiques pour le succès du système.

Planification & Décomposition de Tâches

Pour un objectif complexe comme "Organise mon voyage d'affaires à Londres la semaine prochaine", une simple boucle ReAct ne suffit pas. L'agent doit d'abord **planifier**.

• Planification Simple (Single-Plan) : Le LLM génère une liste d'étapes au début, puis l'orchestrateur les exécute une par une. Rigide, mais simple.
• Planification & Exécution (Plan-and-Execute) : L'agent génère un plan, puis une boucle d'exécution distincte tente de suivre ce plan, en utilisant un agent ReAct pour chaque étape. Plus robuste.
• Planification Hiérarchique : L'agent décompose un objectif en sous-objectifs, qui peuvent eux-mêmes être décomposés. Cela permet de gérer une très grande complexité, souvent en déléguant les sous-tâches à d'autres agents spécialisés.

Systèmes Multi-Agents

Au lieu d'un seul agent omniscient, on peut créer une "équipe" d'agents spécialisés qui collaborent. C'est une approche puissante pour la résolution de problèmes complexes.

Gestion du Contexte dans les Pipelines Agentiques

Le contexte est le carburant de l'agent. Il est accumulé, passé entre les étapes et doit être géré avec soin.

Frameworks d'Orchestration Populaires

Pièges & Challenges

• Boucles infinies : L'agent peut se retrouver coincé, tentant la même action qui échoue en permanence. Un compteur de maximum d'itérations est une sécurité indispensable.
• Coûts imprévisibles : Un agent qui décide de faire 10 recherches web et 5 appels à GPT-4 pour répondre à une question simple peut rapidement devenir très cher. Mettez en place un monitoring et des budgets stricts.
• "Prompt Brittleness" : La performance de l'agent est hypersensible à la formulation du prompt système et des descriptions des outils. Un petit changement peut radicalement altérer son comportement.

Snippet 1 : Définir un Outil (Tool) avec LangChain

from langchain_core.tools import tool
from pydantic import BaseModel, Field

# 1. Définir le schéma d'entrée avec Pydantic
class SearchInput(BaseModel):
    query: str = Field(description="The search query to look for.")

# 2. Créer l'outil avec le décorateur @tool
@tool(args_schema=SearchInput)
def web_search(query: str) -> str:
    """
    Use this tool to search the web for recent information.
    The description is crucial for the agent to know when to use it.
    """
    # ... (code to call a search API like DuckDuckGo, Tavily, etc.)
    return f"Results for '{query}': ..."

# L'agent peut maintenant être initialisé avec [web_search]
# Le LLM verra le nom, la description, et le schéma d'arguments.

Snippet 2 : Pseudo-code d'un Orchestrateur ReAct

def run_react_loop(goal, tools):
    scratchpad = ""
    max_turns = 10
    
    for i in range(max_turns):
        # 1. Construire le prompt avec l'historique
        prompt = f"""
        Goal: {goal}
        
        You have access to these tools: {[t.name for t in tools]}
        
        Scratchpad (your previous thoughts and actions):
        {scratchpad}
        
        Thought:
        """
        
        # 2. Le LLM génère sa pensée et l'action à suivre
        response = llm.invoke(prompt) # ex: "I need to search for X. Action: web_search(query='X')"
        thought, action = parse_llm_response(response)
        
        scratchpad += f"Thought: {thought}\nAction: {action}\n"
        
        # 3. Si l'action est une réponse finale, on arrête
        if is_final_answer(action):
            return get_final_answer(action)
            
        # 4. Exécuter l'outil et obtenir l'observation
        observation = execute_tool(action, tools)
        scratchpad += f"Observation: {observation}\n"

    return "Agent could not reach a conclusion."

Playbook de Déploiement

1. Étape 1 : Commencer avec le "Tool Using", pas les agents. Avant de construire une boucle, assurez-vous que votre LLM peut choisir de manière fiable parmi un ensemble d'outils pour répondre à une question en un seul tour. C'est la base.
2. Étape 2 : Construire un agent ReAct simple. Utilisez un framework pour implémenter une boucle ReAct simple avec 2-3 outils. L'objectif est de valider que l'agent peut chaîner quelques actions pour atteindre un but.
3. Étape 3 : Obsédez-vous sur les descriptions d'outils. La majorité de vos efforts de "prompt engineering" doit se concentrer sur l'amélioration des descriptions des outils pour les rendre aussi claires et non ambiguës que possible.
4. Étape 4 : Utiliser des graphes d'états pour les workflows complexes. Dès que votre logique nécessite des boucles, des branches ou une intervention humaine, abandonnez les simples chaînes d'agents et passez à un modèle de graphe d'états comme **LangGraph**. C'est beaucoup plus robuste et maintenable.
5. Étape 5 : Réserver les systèmes multi-agents aux problèmes collaboratifs. Ne complexifiez pas votre architecture avec plusieurs agents si un seul agent bien "outillé" peut faire le travail. Utilisez les multi-agents pour des tâches qui bénéficient intrinsèquement de "points de vue" ou de rôles différents.
6. Étape 6 : Mettre en place des gardes-fous stricts. Implémentez des limites sur le nombre de tours, le coût total, et exigez une validation humaine pour toute action sensible avant même de penser à la production.