Ces robots IA vont faire votre recherche à votre place : voici comment

UN PROBLÈME COURANT DANS LES AGENTS DE Recherche

Quand un agent IA lit dix pages web, sa fenêtre de contexte (la quantité de texte qu’un grand modèle de langage peut traiter en une seule fois) se remplit de données brutes. S’il doit aussi exécuter du code pour analyser ces données, les graphiques et le raisonnement stratégique se disputent l’espace disponible. Les équipes contournent souvent ce problème avec des enchaînements manuels de prompts ou des traitements séquentiels, ce qui ralentit tout.

Une solution plus efficace consiste à déléguer le travail approfondi à des sous-agents spécialisés. Ces sous-agents effectuent leur tâche en isolation et ne renvoient que des résultats concis. LangChain Deep Agents gère cette orchestration en créant des sous-agents éphémères et en supervisant leur cycle de vie. Amazon Bedrock AgentCore fournit l’infrastructure dont chaque sous-agent a besoin : un navigateur réel dans une MicroVM (une machine virtuelle légère et dédiée) pour la recherche web, et un environnement Python complet pour l’analyse de données.

COMMENT ÇA FONCTIONNE : L’ARCHITECTURE EN QUATRE ÉTAPES

Voici le déroulement complet : le coordinateur reçoit la demande. Il vérifie d’abord si des informations de recherche précédentes sont stockées dans la mémoire à long terme d’AgentCore. Ensuite, il lance trois sous-agents de recherche en parallèle, chacun naviguant sur un site concurrent dans sa propre MicroVM. Une fois les données récupérées, un sous-agent analyste reçoit les résultats combinés et utilise un interpréteur de code pour générer un graphique comparatif et un rapport en markdown. Enfin, les insights clés sont enregistrés dans la mémoire à long terme pour les futures sessions. L’ensemble du flux peut être suivi via Amazon CloudWatch grâce à l’observabilité intégrée d’Amazon Bedrock AgentCore ou à LangSmith.

Chaque type de sous-agent n’a accès qu’à ses outils spécifiques : les outils de navigateur pour les chercheurs, les outils d’interpréteur pour l’analyste, et les outils de mémoire pour le coordinateur.

LES COMPOSANTS À CONFIGURER

Pour construire cet agent, il faut d’abord configurer un modèle, créer des kits d’outils pour chaque type de sous-agent, puis les assembler avec LangChain Deep Agents. Voici les étapes détaillées.

1. CONFIGURER LE MODÈLE DE LANGAGE

Ce code configure le grand modèle de langage qui orchestrera votre agent. Dans cet exemple, on utilise Claude Sonnet 4.6 via Amazon Bedrock :

from langchain_aws import ChatBedrockConverse
from langchainaws.tools import createbrowsertoolkit, createcodeinterpretertoolkit
from deepagents import createdeepagent
from botocore.config import Config as BotoConfig

model = ChatBedrockConverse(
    model="us.anthropic.claude-sonnet-4-6",
    region_name="us-west-2",
    config=BotoConfig(read_timeout=300),
)

Le préfixe us. utilise un profil d’inférence inter-région pour une disponibilité accrue. Vous pouvez aussi utiliser l’identifiant de base du modèle directement.

2. CRÉER LES SOUS-AGENTS DE RECHERCHE

Chaque concurrent reçoit son propre BrowserToolkit, qui provisionne sa propre MicroVM navigateur. Vous obtenez une isolation complète entre les chercheurs en parallèle. Le kit gère la concurrence quand le modèle émet plusieurs appels d’outils de navigateur en un seul tour :

COMPETITORS = [
    ("GitHub", "https://github.com/pricing"),
    ("GitLab", "https://about.gitlab.com/pricing"),
    ("Bitbucket", "https://www.atlassian.com/software/bitbucket/pricing"),
]

toolkitstocleanup = []
research_subagents = []

for companyname, companyurl in COMPETITORS:
    browsertoolkit, browsertools = createbrowsertoolkit(region="us-west-2")
    browsertoolkit.sessionmanager.sessionwaittimeout = 60.0
    toolkitstocleanup.append(browser_toolkit)

    research_subagents.append({
        "name": f"research-{company_name.lower()}",
        "description": f"Researches {companyname} by browsing {companyurl}.",
        "systemprompt": RESEARCHERPROMPT,
        "tools": browser_tools,
    })

Chaque MicroVM exécute un vrai navigateur Chromium connecté via WebSocket avec Playwright (une bibliothèque open source d’automatisation de navigateur). Les sessions sont éphémères et se lancent en quelques secondes. Le sessionwaittimeout est réglé à 60 secondes (par défaut : 10 secondes) pour laisser suffisamment de temps aux opérations du navigateur quand plusieurs appels d’outils s’exécutent en concurrence. Les outils du navigateur incluent navigate_browser, extract_text, click_element, type_text, scroll_page, extract_hyperlinks, et waitforelement.

3. CRÉER LE SOUS-AGENT ANALYSTE

Le sous-agent analyste utilise l’AgentCore Code Interpreter, une MicroVM isolée exécutant un environnement Python complet avec pandas, matplotlib et numpy préinstallés :

citoolkit, citools = await createcodeinterpreter_toolkit(region="us-west-2")
toolkitstocleanup.append(ci_toolkit)

analyst_subagent = {
    "name": "data-analyst",
    "description": "Analyzes competitor data, generates charts and reports.",
    "systemprompt": ANALYSTPROMPT,
    "tools": ci_tools,
}

Les outils de l’interpréteur incluent execute_code, execute_command, write_files, read_files, list_files, upload_file, et install_packages. Besoin de bibliothèques supplémentaires ? Utilisez l’outil install_packages pour les ajouter à l’exécution.

4. CONFIGURER LA MÉMOIRE À LONG TERME

Le coordinateur peut accumuler de l’expertise au fil du temps grâce aux outils de mémoire d’AgentCore qui interagissent directement avec l’API de mémoire à long terme :

from bedrock_agentcore.memory import MemoryClient
from langchain_core.tools import tool

memoryclient = MemoryClient(regionname="us-west-2")

@tool
def saveresearchinsights(insights: str, session_id: str = "default") -> str:
    """Save competitive research insights to AgentCore long-term memory."""
    memoryclient.createevent(
        memoryid=memoryid, actorid=actorid, sessionid=sessionid,
        messages=[
            (f"Save these research insights:\n\n{insights}", "USER"),
            ("Insights saved to long-term memory.", "ASSISTANT"),
        ],
    )
    return "Insights saved and are extracted into long-term memory."

Important : votre ressource AgentCore Memory doit avoir au moins une stratégie d’extraction configurée (comme semanticMemoryStrategy) pour que la récupération à long terme fonctionne. Sans stratégie, create_event stocke les événements bruts, mais aucune information n’est extraite pour la récupération.

Quand l’agent sauvegarde des insights, les stratégies configurées d’AgentCore Memory extraient automatiquement les connaissances structurées en arrière-plan. Lors des exécutions suivantes, l’agent utilise recallpastresearch pour rechercher ces connaissances extraites. Il trouve les faits et résultats passés sans avoir à refaire la recherche depuis zéro.

ASSEMBLER LE TOUT ET LANCER L’AGENT

Voici comment assembler les composants et invoquer l’agent :

agent = createdeepagent(
    model=model,
    subagents=[*researchsubagents, analystsubagent],
    tools=memory_tools,
    systemprompt=COORDINATORPROMPT,
    name="competitive-research-coordinator",
    checkpointer=None,  # Simplification ; utilisez AgentCoreMemorySaver pour la reprise de session
    store=InMemoryStore(),  # Stockage interne pour Deep Agents (séparé de la mémoire AgentCore)
)

result = await agent.ainvoke(
    {"messages": [{"role": "user", "content": "Compare pricing for GitHub, GitLab, and Bitbucket"}]},
    config={"configurable": {"threadid": "session-1", "actorid": "research-agent"}},
)

Le notebook accompagnant propose une version exécutable avec des indicateurs de progression et un affichage de session. Le temps d’exécution attendu est de 4 à 6 minutes avec Claude Sonnet, reflétant le temps réel de navigation sur trois sites. Un traitement séquentiel de la même recherche prendrait jusqu’à trois fois plus de temps.

OBSERVER LE FONCTIONNEMENT AVEC AMAZON CLOUDWATCH

AgentCore Observability vous donne une visibilité sur cette architecture multi-agents via Amazon CloudWatch. AgentCore émet des traces et des spans au format OpenTelemetry (OTEL), ce qui permet d’afficher la hiérarchie complète de l’orchestration sur la page d’observabilité GenAI de CloudWatch : l’exécution du coordinateur au niveau supérieur, un span enfant pour chaque sous-agent de recherche, et le sous-agent analyste qui suit. Dans chaque span, vous pouvez consulter les appels d’outils avec leurs entrées, sorties, temps d’exécution et consommation de tokens. Vous pouvez confirmer que les sous-agents de recherche s’exécutent en concurrence grâce à leur timing d’horloge murale, et identifier quel sous-agent et quel appel d’outil a rencontré un problème quand une navigation ou une exécution de code échoue.

Pour activer les traces, il faut configurer une fois par compte la CloudWatch Transaction Search avant que les traces et spans ne deviennent disponibles. Quand vous hébergez l’agent sur AgentCore Runtime, l’exécution instrumente automatiquement votre agent avec OTEL, donc aucune configuration supplémentaire n’est nécessaire. Pour exécuter le même agent en dehors de l’exécution, ajoutez le AWS Distro for OpenTelemetry (ADOT) SDK et la bibliothèque d’instrumentation de LangChain à votre agent. Pour plus d’informations, consultez la documentation sur l’observabilité d’Amazon Bedrock AgentCore.

Vous pouvez aussi évaluer la qualité de ces traces avec Amazon Bedrock AgentCore Evaluations, qui fournit des évaluateurs intégrés comme le taux de réussite des objectifs et la précision du choix des outils. Pour plus de détails, consultez la documentation sur les évaluations d’AgentCore.

Si vous préférez, vous pouvez aussi utiliser LangSmith pour le traçage. Avec LangSmith, vous obtenez un traçage de bout en bout qui vous aide à déboguer cette architecture multi-agents. Configurez trois variables d’environnement pour activer le traçage automatique :

export LANGCHAINTRACINGV2=true
export LANGCHAINAPIKEY="your-langsmith-api-key"
export LANGCHAIN_PROJECT="competitive-research-agent"

Le notebook accompagnant détaille cette option.

POURQUOI CE MODÈLE EST-IL SI PUISSANT ?

Premièrement, le coordinateur se concentre sur le raisonnement de haut niveau. Chaque sous-agent de recherche gère le travail complexe de navigation en interne et ne renvoie qu’un résumé concis, gardant la fenêtre de contexte du coordinateur disponible pour la synthèse plutôt que remplie de contenu de page brut.

Deuxièmement, vous obtenez une séparation claire entre les capacités. Chaque type de sous-agent n’accède qu’à ses propres outils, ce qui réduit les risques d’utilisation accidentelle d’outils et rend le débogage plus ciblé.

Troisièmement, la recherche est plus rapide. Trois tâches de recherche sur navigateur s’exécutent en concurrence, chacune dans sa propre MicroVM AgentCore, réduisant le temps d’horloge murale par rapport à un traitement séquentiel.

Enfin, Amazon Bedrock AgentCore est indépendant du modèle et du framework. Les outils AgentCore (Navigateur, Interpréteur, Mémoire) fonctionnent de manière identique quel que soit le modèle qui les orchestrent. Vous pouvez remplacer le modèle en une seule ligne de changement :

# Par défaut : Amazon Bedrock
from langchain_aws import ChatBedrockConverse
model = ChatBedrockConverse(model="us.anthropic.claude-sonnet-4-6", region_name="us-west-2")

# Alternative : API Anthropic directement
# from langchain_anthropic import ChatAnthropic
# model = ChatAnthropic(model="claude-sonnet-4-6")

# Alternative : Google Gemini
# from langchaingooglegenai import ChatGoogleGenerativeAI
# model = ChatGoogleGenerativeAI(model="gemini-2.5-pro")

DÉPLOYER L’AGENT SUR AGENTCORE RUNTIME

L’agent que vous avez construit s’exécute dans un notebook, ce qui est pratique pour le développement. Pour le déplacer vers un endpoint géré avec isolation par session et un ARN d’invocation stable, vous pouvez l’héberger sur Amazon Bedrock AgentCore Runtime. AgentCore Runtime héberge votre agent dans un conteneur ARM64 et exécute chaque session dans une microVM dédiée pendant jusqu’à 8 heures. Comme il est indépendant du framework, votre coordinateur Deep Agents, les sous-agents de navigateur en parallèle et le sous-agent analyste s’exécutent sans modification.

Le CLI d’AgentCore gère le flux de déploiement en quatre étapes : créer le projet avec agentcore create, mettre à jour le template avec votre code d’agent, déployer avec agentcore deploy, et invoquer avec agentcore invoke. Après le déploiement, vous pouvez consulter les logs avec agentcore logs et inspecter les traces avec agentcore traces. Quand vous avez terminé, agentcore remove suivi de agentcore deploy détruit toutes les ressources provisionnées.

La partie 2 du notebook détaille chacune de ces étapes, y compris les prérequis et les permissions IAM.

NETTOYER LES RESSOURCES POUR ÉVITER LES FRAIS

Pour éviter d’engendrer des frais, nettoyez les ressources AgentCore que vous avez créées :

# Nettoyer les sessions de navigateur
for toolkit in browser_toolkits:
    await toolkit.cleanup()

# Nettoyer la session de l'interpréteur
await ci_toolkit.cleanup()

Les sessions de navigateur expirent automatiquement après 1 heure. Les sessions de l’interpréteur expirent automatiquement après 15 minutes. Le notebook accompagnant inclut un code de nettoyage qui s’exécute automatiquement. Si vous avez créé une ressource AgentCore Memory et n’en avez plus besoin, vous pouvez la supprimer via la console ou l’API Amazon Bedrock AgentCore.

AU-DELÀ DE LA RECHERCHE CONCURRENTIELLE : D’AUTRES CAS D’USAGE

Dans cet article, vous avez construit un agent de recherche qui utilise LangChain Deep Agents pour l’orchestration, Amazon Bedrock AgentCore pour l’automatisation isolée du navigateur, l’interprétation de code et la mémoire persistante. Vous avez déployé l’agent sur AgentCore Runtime via le CLI AgentCore pour l’exécuter comme un service géré avec isolation par session, un endpoint stable et une observabilité intégrée.

Ce modèle d’acquisition parallèle de données, de traitement spécialisé et de synthèse s’applique à de nombreux flux de travail au-delà de la recherche concurrentielle : analyse de tendances, veille technologique, benchmarking de produits, ou même recherche académique approfondie.

COMMENT DÉMARRER ?

Pour commencer, ouvrez le notebook accompagnant et suivez l’exécution cellule par cellule. Si vous avez des questions ou des retours sur cette solution, laissez un commentaire sur cet article.

Pour plus d’informations sur les services utilisés dans cet article, consultez :