Plusieurs entreprises spécialisées en IA introduisent désormais des systèmes d’IA agentiques capables d’effectuer des recherches approfondies sur le sujet demandé et de produire un rapport complet, comme Deep Research d’OpenAI.
Les systèmes d’IA agentiques comme Deep Research d’OpenAI offrent des pipelines automatisés pour des tâches complexes telles que la recherche en plusieurs étapes et la synthèse. Mais la plupart des solutions existantes sont propriétaires, difficiles à personnaliser et limitent votre contrôle sur le comportement du modèle et le traitement des données.
Par exemple, vous pourriez souhaiter utiliser un LLM différent, un moteur de recherche personnalisé ou ajuster la manière dont les agents planifient et se comportent pour produire des résultats spécifiques.
Cela nous amène à une question intéressante : pouvez-vous créer votre propre agent de recherche approfondi avec une flexibilité totale, où vous pouvez utiliser votre modèle d’IA préféré, intégrer votre moteur de recherche préféré et personnaliser le comportement de l’agent ? La réponse est oui.
Dans cet article, vous apprendrez à construire votre propre agent de recherche approfondi en utilisant Novita AI, LangChain et Tavily.
Qu’est-ce qu’un workflow d’agent de recherche approfondi ?
La recherche traditionnelle prend souvent beaucoup de temps, car elle implique généralement de passer au crible de nombreuses informations disponibles en ligne et, au final, peut ne pas conduire à des informations exploitables. Un workflow d’agent de recherche approfondi résout ces problèmes grâce à des agents d’IA capables de raisonner de manière autonome, de prendre des décisions et de coordonner des outils externes dans le cadre d’un workflow.
Ce workflow implique généralement :
- Structuration de la tâche : l’agent d’IA décompose le sujet en tâches plus petites.
- Planification : l’agent crée des stratégies pour aborder chaque tâche, ce qui aide le workflow à déterminer la séquence d’exécution des tâches.
- Intégration des outils : pour recueillir des informations, l’agent utilise différents outils, tels que des bases de données et des moteurs de recherche web. Sans ces outils, l’agent ne peut pas effectuer les actions clés du workflow.
- Synthèse : l’agent analyse les informations recueillies et les combine en données cohérentes.
- Génération du rapport : après avoir synthétisé les données, l’agent crée un rapport structuré comprenant des résumés et des citations.
Outils nécessaires
Avant d’aborder la partie construction de cet article, configurons les outils nécessaires.
Novita AI
Pour construire le workflow agentique, nous avons besoin d’un LLM, et Novita AI fournit une API abordable et performante qui vous donne accès aux derniers LLM, modèles de génération d’images et plus encore.
Connectez-vous à Novita AI pour commencer. Une fois connecté, accédez à Settings > Key Management et suivez les instructions pour générer une clé API.
Notez que si vous vous inscrivez, Novita AI vous fournira des crédits gratuits pour essayer divers modèles, vous n’avez donc pas à vous soucier d’acheter des crédits avant de commencer à construire ou à expérimenter.
Tavily
Tavily est une API de recherche web avancée optimisée pour les applications d’IA. Avec l’outil de moteur de recherche de Tavily, nous pouvons donner à notre agent un accès à Internet pour recueillir des informations précises et impartiales. Rendez-vous sur Tavily et générez une clé API.
LangChain
LangChain est un framework open source conçu pour construire des applications avec les LLM. Avec LangChain, vous pouvez créer un workflow agentique qui raisonne étape par étape, utilise des outils et interagit avec des API. Pour notre agent de recherche approfondi, nous utiliserons LangChain pour structurer le processus de recherche, utiliser des outils comme la recherche web et synthétiser le tout en un rapport structuré.
Google Colab
Dans ce tutoriel, nous construirons et testerons l’agent de recherche approfondi en utilisant Google Colab. Colab vous permet d’écrire et d’exécuter du code Python dans votre navigateur sans aucune configuration préalable, ce qui rend le tutoriel simple à suivre.
Aperçu du workflow
La recherche agentique approfondie est une combinaison de différentes étapes du workflow, de la planification de la tâche de recherche à la livraison du rapport de recherche final. Passons en revue chaque étape du workflow pour comprendre comment l’application fonctionne.
Planification de la recherche
C’est la première étape du workflow. Ici, l’agent analyse le sujet et crée un plan de recherche structuré basé sur le contexte du sujet. Il décompose le sujet large en sous-thèmes ciblés comme l’historique, les détails techniques, les avantages et inconvénients, les cas d’utilisation, etc.
Vous pouvez considérer cela comme la partie la plus importante du workflow, car sans elle, l’agent pourrait effectuer des recherches génériques et renvoyer des résultats non pertinents.
Recherche approfondie
Les LLM sont limités à leurs données d’entraînement et ne peuvent pas accéder aux tendances actuelles. Par exemple, si vous demandez à l’agent sans capacité de recherche de lister les joueurs actuels d’une équipe de football, il renverra des résultats basés sur les données sur lesquelles il a été entraîné. Cependant, comme ces résultats ne contiennent pas les mises à jour les plus récentes, ils peuvent ne plus être factuellement corrects.
L’utilisation de Tavily pour effectuer des recherches web avancées donne à l’agent un accès aux sources web les plus récentes et les plus pertinentes.
Gestion des sources
Pour garantir que chaque information produite par l’agent puisse être liée à une source fiable, il est important de suivre toutes les sources. Cette partie du workflow renforce la confiance des utilisateurs qui souhaitent vérifier les affirmations ou les données du rapport final.
Synthèse
Pour relier toutes les informations recueillies, l’agent rassemble les perspectives de tous les aspects recherchés pour former un rapport cohérent. Sans cette phase du workflow, le résultat de la recherche pourrait n’être qu’un rapport décousu.
Mise en forme finale
Même si le rapport est factuellement exact et bien recherché, une mauvaise mise en forme peut le rendre difficile à lire. Une étape supplémentaire est nécessaire pour garantir une structure propre, des titres cohérents, des puces, un espacement, etc.
Implémentation de l’agent de recherche approfondi
Jusqu’à présent, vous avez compris ce qu’est un workflow d’agent de recherche approfondi. Il est maintenant temps de l’implémenter dans Google Colab.
Pour commencer, nous allons effectuer quelques étapes clés :
Étape 1 : Installer les dépendances
-q langchain langchain-openai tavily-python
Étape 2 : Importer les bibliothèques nécessaires
# Import des bibliothèques Python standard
import os # Pour interagir avec les variables d'environnement
import re # Pour les expressions régulières
import ast # Pour analyser en toute sécurité des expressions Python à partir de chaînes
# Modèles et outils LangChain
from langchain_openai import ChatOpenAI # Interface pour interagir avec les modèles de chat OpenAI
from langchain_community.utilities.tavily_search import TavilySearchAPIWrapper # Permet la recherche via l'API Tavily
# Schéma de messages LangChain
from langchain.schema import SystemMessage, HumanMessage # Définit les types de messages utilisés dans les conversations
# Composants d'agent LangChain
from langchain.agents import Tool, AgentExecutor, create_react_agent # Pour construire et exécuter des workflows agentiques avec des outils
# Modèles de prompt LangChain
from langchain.prompts import PromptTemplate # Permet de créer des modèles de prompt réutilisables
# Mémoire LangChain
from langchain.memory import ConversationBufferMemory # Aide à maintenir l'état de la conversation entre les tours
Étape 3 : Configurer les variables d’environnement
# Définition et récupération des variables d'environnement
os.environ["NOVITA_API_KEY"] = "" # Remplacez par votre clé API Novita
os.environ["TAVILY_API_KEY"] = "" # Remplacez par votre clé API Tavily
# Chargement des clés API dans des variables
novita_api_key = os.getenv("NOVITA_API_KEY")
tavily_api_key = os.getenv("TAVILY_API_KEY")
Étape 4 : Définir une fonction d’assistance LLM
Novita AI est compatible avec OpenAI ; nous allons donc utiliser le module ChatOpenAI de LangChain pour intégrer Novita AI avec LangChain. Cela signifie que nous pouvons communiquer avec Novita de la même manière qu’avec les modèles OpenAI.
Cependant, un point important à noter est que nous devons définir le paramètre base_url pour qu’il pointe vers le point de terminaison de l’API de Novita : https://api.novita.ai/v3/openai.
Dans ce workflow, nous utiliserons le modèle llama-4-maverick-17b-128e-instruct-fp8, une variante puissante de LLaMA 4 affinée pour les tâches de suivi d’instructions.
# Fonction d'assistance LLM
def llm(api_key,
model="meta-llama/llama-4-maverick-17b-128e-instruct-fp8",
temperature=0.7):
"""Crée une instance ChatOpenAI LLM avec les paramètres spécifiés."""
return ChatOpenAI(
model=model,
openai_api_key=api_key,
base_url="https://api.novita.ai/v3/openai",
temperature=temperature,
)
Construction du chercheur agentique
L’ensemble du workflow de recherche approfondie est encapsulé dans une classe modulaire appelée AgenticResearcher. Cette classe gérera le processus de génération des plans de recherche, d’exécution des recherches web, de synthèse des résultats, de mise en forme du rapport final et d’exécution de la boucle de recherche complète.
Nous allons initialiser l’agent de recherche avec un accès à un LLM via l’API Novita et un outil de recherche web via l’API Tavily. Ensuite, nous définissons une méthode qui effectue une recherche web avancée sur une requête donnée en utilisant Tavily. Les résultats sont formatés pour être lisibles, et les données brutes sont stockées pour une utilisation ultérieure.
class AgenticResearcher:
def __init__(self, novita_api_key, tavily_api_key, num_researchers=3, temperature=0.3):
"""Initialise l'agent de recherche avec les clés API et paramètres nécessaires."""
self.llm = llm(api_key=novita_api_key, temperature=temperature)
self.tavily_search = TavilySearchAPIWrapper(tavily_api_key=tavily_api_key)
self.num_researchers = num_researchers
self.raw_search_results = []
def search(self, query):
"""Recherche sur le web des informations sur une requête donnée."""
try:
results = self.tavily_search.results(
query, max_results=7,
search_depth="advanced"
)
# Stockage des résultats bruts pour le traitement des citations
self.raw_search_results.extend(results)
formatted = []
for r in results:
formatted += [
f"TITRE : {r.get('title','')}",
f"URL : {r.get('url','')}",
f"CONTENU :\
{r.get('content','')}",
"---"
]
return "\
".join(formatted) if formatted else "Aucun résultat trouvé"
except Exception as e:
return f"Erreur de recherche : {str(e)}"
Création de plans de recherche multi-aspects
Toujours dans la classe AgenticResearcher, créons une méthode qui génère un plan de recherche structuré en décomposant le sujet en plusieurs aspects distincts à l’aide du LLM. Chaque aspect comprend un titre et une requête de recherche spécifique. L’objectif est d’explorer le sujet sous plusieurs angles pour garantir à la fois profondeur et ampleur.
def create_research_plan(self, topic):
"""Crée un plan de recherche structuré avec plusieurs aspects à explorer."""
sys = "Vous êtes un planificateur qui produit des listes Python de dictionnaires."
hum = f"""
Créez un plan de recherche complet pour : {topic}
Identifiez {self.num_researchers} aspects distincts à explorer en profondeur.
Analysez le sujet et déterminez les aspects les plus pertinents à rechercher en fonction de sa nature et de son domaine.
Sortie exacte :
ASPECT {{'title': '...', 'search_query': '...'}}
"""
try:
resp = self.llm.invoke([SystemMessage(content=sys), HumanMessage(content=hum)])
aspects = []
for line in resp.content.splitlines():
if line.strip().startswith("ASPECT"):
m = re.search(r"\{.*\}", line)
if m:
try:
aspects.append(ast.literal_eval(m.group(0)))
except Exception as e:
print(f"Erreur lors de l'analyse de l'aspect : {e}")
if not aspects:
# Aspects par défaut généralistes qui fonctionnent pour différents domaines
default_aspects = [
{"title": "Vue d'ensemble et informations clés", "search_query": f"{topic} vue d'ensemble faits clés"},
{"title": "Contexte et historique", "search_query": f"{topic} contexte historique général"},
{"title": "Détails et spécifications", "search_query": f"{topic} détails spécificités données"},
{"title": "Analyse et importance", "search_query": f"{topic} analyse importance implications"}
]
aspects = default_aspects[:self.num_researchers]
return aspects
except Exception as e:
print(f"Erreur lors de la création du plan de recherche : {e}")
return [{"title": f"Recherche sur {topic}", "search_query": topic}]
Gestion des sources et citations
Ensuite, nous devons gérer la manière dont le workflow génère des rapports crédibles. Pour cela, nous allons créer une méthode qui extrait les sources uniques des résultats de recherche bruts, en s’assurant que chaque source est citée.
def extract_sources(self):
"""Extrait les sources uniques des résultats de recherche bruts pour les citations."""
unique_sources = {}
for result in self.raw_search_results:
url = result.get('url', '')
if url and 'http' in url:
domain = url.split('/')[2] if len(url.split('/')) > 2 else url
if domain not in unique_sources:
unique_sources[domain] = url
return unique_sources
Synthèse du rapport
Maintenant que nous avons recueilli des informations brutes provenant de plusieurs sources, l’étape suivante consiste à transformer cette entrée désorganisée en un rapport de recherche détaillé. Nous allons écrire des méthodes qui synthétisent le texte brut en un rapport lisible et organisé, avec des titres, des sous-titres, des conclusions clés et des citations de sources.
def synthesize(self, text):
"""Synthétise le texte brut en conclusions structurées détaillées avec citations."""
sources = self.extract_sources()
sources_list = list(sources.keys())
sys = """Vous êtes un expert en synthèse de recherche qui crée des rapports détaillés et structurés.
Pour chaque affirmation ou fait que vous incluez, ajoutez une citation vers le domaine source.
Utilisez les noms de domaine exacts fournis sans modification.
Adaptez la structure de votre rapport au domaine et à la nature du sujet."""
hum = f"""
INFORMATIONS À SYNTHÉTISER :
{text}
DOMAINES SOURCES DISPONIBLES (utilisez ces noms exacts pour les citations) :
{sources_list}
Créez un rapport de recherche complet et détaillé avec :
1. Les principales conclusions avec des faits et chiffres spécifiques
2. Des informations structurées avec des titres et sous-titres clairs et adaptés au sujet
3. Des citations utilisant les noms de domaine sources exacts entre crochets [comme.ceci]
4. Des données pertinentes présentées de manière claire et professionnelle
5. Un format adapté à la nature spécifique du sujet (technique, historique, actualité, etc.)
FORMATEZ LE RAPPORT DE MANIÈRE PROFESSIONNELLE ET APPROFONDIE SANS SUPPOSER DE DOMAINE SPÉCIFIQUE.
"""
try:
return self.llm.invoke([SystemMessage(content=sys), HumanMessage(content=hum)]).content
except Exception as e:
return f"Erreur de synthèse : {str(e)}"
Création d’outils pour l’agent
Pour rendre notre workflow d’agent de recherche approfondi fonctionnel, nous devons définir les outils. Les outils donnent à l’agent des capacités pour effectuer certaines actions.
Les outils de base nécessaires pour ce workflow sont “plan” pour aider l’agent à décomposer le sujet et créer un plan de recherche structuré, “search” pour permettre à l’agent d’effectuer une recherche web approfondie, et “synthesize” pour permettre à l’agent de convertir toutes les conclusions brutes en un rapport organisé.
def get_tools(self):
"""Crée et retourne la liste des outils disponibles pour l'agent."""
return [
Tool(
name="plan",
func=lambda t: str(self.create_research_plan(t)),
description="Crée un plan de recherche détaillé avec plusieurs aspects à explorer."
),
Tool(
name="search",
func=self.search,
description="Recherche sur le web de manière approfondie une requête et retourne des résultats complets."
),
Tool(
name="synthesize",
func=self.synthesize,
description="Transforme le texte brut en conclusions structurées détaillées avec citations."
),
]
Construction de l’exécuteur d’agent
Maintenant que nos outils sont prêts, nous devons tout rassembler dans un agent d’IA en utilisant un style de prompt ReAct. Cela aide l’agent à planifier, à prendre des actions en utilisant les outils définis, à observer les résultats et à boucler jusqu’à ce qu’il ait suffisamment de données pour produire un rapport de recherche final.
def get_agent_executor(self):
"""Crée et retourne l'exécuteur d'agent avec les outils et la mémoire."""
tools = self.get_tools()
template = """Vous êtes un agent de recherche autonome spécialisé dans la production de rapports complets et détaillés sur n'importe quel sujet.
{tool_names}
OUTILS :
{tools}
CONVERSATIONS PRÉCÉDENTES :
{chat_history}
Lorsqu'on vous donne un sujet de recherche (comme {input}), suivez ce processus :
1. Analysez le type de sujet et créez un plan de recherche adapté à son domaine
2. Recherchez des informations complètes sur chaque aspect du sujet
3. Collectez des informations détaillées et pertinentes avec des sources
4. Synthétisez le tout en un rapport professionnel et détaillé, formaté de manière appropriée pour le sujet
Suivez exactement ce format :
Question : {input}
Pensée : (votre raisonnement ici)
Action : le nom de l'outil à appeler, doit être l'un de [{tool_names}]
Action Input : l'entrée pour l'outil
Observation : (la sortie de l'outil)
... (répétez Pensée/Action/Action Input/Observation si nécessaire)
Lorsque vous avez recueilli suffisamment d'informations, sortez :
Réponse finale : (votre rapport de recherche final détaillé avec des sections structurées, un formatage approprié, des détails spécifiques et des citations)
COMMENCEZ PAR UN PLAN APPROFONDI !
{agent_scratchpad}
"""
prompt = PromptTemplate(
template=template,
input_variables=["input", "agent_scratchpad", "tools", "tool_names", "chat_history"]
)
# Création de l'agent de bas niveau
agent = create_react_agent(
llm=self.llm,
tools=tools,
prompt=prompt
)
# Encapsulation dans un exécuteur avec mémoire
memory = ConversationBufferMemory(memory_key="chat_history", return_messages=True)
agent_executor = AgentExecutor.from_agent_and_tools(
agent=agent,
tools=tools,
verbose=True,
memory=memory,
max_iterations=18,
early_stopping_method="generate",
handle_parsing_errors=True
)
return agent_executor
Mise en forme finale du rapport
Une fois que l’agent de recherche a terminé sa recherche approfondie, la sortie peut être informative mais pas présentable. Cette étape supplémentaire permet de rendre le rapport final plus soigné. Pour y parvenir, nous allons demander au LLM de travailler comme un éditeur expert pour améliorer le rapport final.
def format_final_report(self, raw_report):
"""Ajoute une mise en forme finale au rapport pour le rendre plus professionnel."""
sys = """Vous êtes un éditeur expert qui améliore les rapports de recherche.
Conservez tout le contenu factuel, les citations et la structure intacts.
Améliorez simplement la mise en forme, l'organisation et la lisibilité."""
hum = f"""
Voici un rapport de recherche qui nécessite des améliorations de mise en forme finale :
{raw_report}
Veuillez améliorer la mise en forme et la présentation tout en préservant :
1. Les faits et chiffres
2. Les citations
3. L'organisation du contenu
4. Les données statistiques
Rendez-le professionnel avec des titres, un espacement et une mise en page appropriés.
"""
try:
improved = self.llm.invoke([SystemMessage(content=sys), HumanMessage(content=hum)]).content
return improved
except Exception as e:
# Si la mise en forme échoue, retourner le rapport original
return raw_report
Rassembler le tout
Relions l’ensemble du workflow en un pipeline unique qui coordonne tout le flux de recherche. Cela servira de point d’entrée permettant à l’agent d’effectuer l’ensemble du processus de recherche, puis de formater le rapport final.
def run(self, topic):
"""Exécute le processus de recherche sur le sujet donné."""
try:
# Réinitialisation des résultats de recherche stockés
self.raw_search_results = []
# Exécution de l'agent
executor = self.get_agent_executor()
raw_report = executor.invoke({"input": topic})["output"]
# Mise en forme du rapport final
final_report = self.format_final_report(raw_report)
return final_report
except Exception as e:
return f"Échec de la recherche : {str(e)}"
Exécution de l’agent de recherche
Maintenant que nous avons construit le workflow d’agent de recherche approfondi, mettons-le à l’épreuve et voyons à quel point il fonctionne sur une tâche de recherche réelle.
Nous allons créer une instance de l’agent de recherche et lui demander de générer un rapport détaillé sur un sujet d’actualité.
# Création de l'objet chercheur
researcher = AgenticResearcher(novita_api_key, tavily_api_key, num_researchers=3)
# Exécution d'une recherche test
topic = "Quelles sont les startups climatiques les plus prometteuses en 2025 ?"
report = researcher.run(topic)
# Affichage du rapport de recherche
print("\
" + "="*60)
print(f"📝 RAPPORT DE RECHERCHE DÉTAILLÉ : {topic}")
print("="*60)
print(report)
print("="*60 + "\
")
Résultat :
Le workflow agentique approfondi a décomposé le sujet et créé un plan de recherche, effectué une recherche internet pour récupérer les informations pertinentes, synthétisé les données recueillies et enfin renvoyé un rapport structuré basé sur la requête de recherche.
Conclusion
Félicitations pour avoir construit votre propre workflow d’agent de recherche approfondi ! Vous pouvez désormais effectuer des recherches sur n’importe quel sujet et obtenir un rapport détaillé sur votre requête.
Faisons un rapide récapitulatif de ce que vous avez accompli :
Dans cet article, vous avez appris à construire un agent de recherche approfondi capable de décomposer des sujets complexes, de générer un plan de recherche, d’effectuer des recherches internet et de synthétiser toutes les conclusions en un rapport structuré.
L’ensemble de ce workflow a été alimenté par :
- Novita AI en tant que fournisseur de LLM
- LangChain pour le cadre agentique
- Tavily en tant que moteur de recherche en temps réel
N’hésitez pas à essayer l’agent sur différents sujets pour tester ses capacités !
Ce n’est qu’une des nombreuses applications passionnantes de l’IA possibles avec les modèles puissants d’aujourd’hui. Visitez le Novita LLM Playground pour essayer d’autres modèles d’IA récents et performants ; qui sait, votre prochaine grande idée IA pourrait bien y débuter.
Novita AI est une plateforme cloud d’IA qui offre aux développeurs un moyen simple de déployer des modèles d’IA via notre API, tout en fournissant un GPU cloud abordable et fiable pour construire et faire évoluer leurs projets.
