Open Deep Research : l'assistant intelligent open source de LangChain pour la recherche approfondie

Introduction générale

Open Deep Research est un assistant de recherche en ligne qui génère des rapports de recherche complets sur n'importe quel sujet. Le système utilise un flux de travail "planifier et faire" qui permet aux utilisateurs de planifier et de revoir la structure du rapport avant de passer à la phase de recherche qui prend beaucoup de temps. Les utilisateurs peuvent choisir parmi différents modèles de planification, API de recherche et modèles de rédaction tels que Tavily, Perplexity, Anthropic et OpenAI pour répondre à leurs besoins individuels. Open Deep Research prend en charge plusieurs itérations de réflexion et de recherche pour garantir la profondeur et la précision du rapport. Les utilisateurs peuvent rapidement déployer et utiliser l'outil grâce à des fichiers de configuration simples et des opérations en ligne de commande.

Liste des fonctions

• Fournir un aperçu de la structure du rapport
• Mise en place de modèles de planification (par exemple DeepSeek, modèles d'inférence OpenAI, etc.)
• Retour d'information sur les plans de chaque section du rapport et itération jusqu'à ce que les utilisateurs soient satisfaits.
• Définition des API de recherche (par exemple Tavily, Perplexité) et du nombre de recherches par itération de l'étude
• Réglage de la profondeur de recherche (nombre d'itérations) pour chaque section
• Modèles d'écriture personnalisés (par exemple, Anthropic)
• Exécuter LangGraph Studio UI localement
• Génération automatique de rapports de recherche structurés
• Prendre en charge des recherches multiples et des itérations de réflexion pour améliorer la qualité des rapports

Utiliser l'aide

démarrage rapide

1. Assurez-vous que la clé API de l'outil requis a été définie.
2. Sélectionnez un outil de recherche sur le web (Tavily est utilisé par défaut) :
   • Tavily API
   • Perplexité API
3. Sélectionner un modèle d'écriture (Anthropic est utilisé par défaut) Claude 3.5 Sonnet) :
   • Anthropique
   • OpenAI
   • Groq
4. Sélectionnez un modèle de planification (OpenAI o3-mini est utilisé par défaut) :
   • OpenAI
   • Groq

Utilisation

environnement virtualisé

1. Créer un environnement virtuel :

   python -m venv open_deep_research
   source open_deep_research/bin/activate
   

2. Installation :

   pip install open-deep-research
   

Utiliser le Notebook Jupyter dans

1. Importer et compiler le graphique :

   from langgraph.checkpoint.memory import MemorySaver
   from open_deep_research.graph import builder
   memory = MemorySaver()
   graph = builder.compile(checkpointer=memory)
   

2. Voir le graphique :

   from IPython.display import Image, display
   display(Image(graph.get_graph(xray=1).draw_mermaid_png()))
   

3. Exécutez le graphique :

   import uuid 
   thread = {"configurable": {"thread_id": str(uuid.uuid4()),
   "search_api": "tavily",
   "planner_provider": "openai",
   "planner_model": "o3-mini",
   "writer_provider": "anthropic",
   "writer_model": "claude-3-5-sonnet-latest",
   "max_search_depth": 1,
   }}
   topic = "Overview of the AI inference market with focus on Fireworks, Together.ai, Groq"
   async for event in graph.astream({"topic":topic,}, thread, stream_mode="updates"):
   print(event)
   print("\n")
   

4. Après avoir généré le plan de rapport, soumettez un retour d'information pour mettre à jour le plan de rapport :

   from langgraph.types import Command
   async for event in graph.astream(Command(resume="Include a revenue estimate (ARR) in the sections"), thread, stream_mode="updates"):
   print(event)
   print("\n")
   

5. Soumis lorsqu'il est satisfait du système de déclarationTruepour générer des rapports :

   async for event in graph.astream(Command(resume=True), thread, stream_mode="updates"):
   print(event)
   print("\n")
   

Exécuter LangGraph Studio UI localement

1. Entrepôt de clonage :

   git clone https://github.com/langchain-ai/open_deep_research.git
   cd open_deep_research
   

2. compilateur.envpour définir la clé de l'API :

   cp .env.example .env
   

3. Définition des variables d'environnement :

   export TAVILY_API_KEY=<your_tavily_api_key>
   export ANTHROPIC_API_KEY=<your_anthropic_api_key>
   export OPENAI_API_KEY=<your_openai_api_key>
   

4. Démarrer le serveur LangGraph :
   • Mac :

     curl -LsSf https://astral.sh/uv/install.sh | sh
     uvx --refresh --from "langgraph-cli[inmem]" --with-editable . --python 3.11 langgraph dev
     

   • Fenêtres :

     pip install -e .
     pip install langgraph-cli[inmem]
     langgraph dev
     

5. Ouvrez l'interface utilisateur de Studio :

   - 🚀 API: http://127.0.0.1:2024
   - 🎨 Studio UI: https://smith.langchain.com/studio/?baseUrl=http://127.0.0.1:2024
   - 📚 API Docs: http://127.0.0.1:2024/docs
   

Rapports personnalisés

• report_structureFormat des rapports : Définir une structure de rapport personnalisée (le format standard des rapports de recherche est utilisé par défaut).
• number_of_queries: nombre de requêtes de recherche générées par section (par défaut : 2)
• max_search_depthProfondeur de recherche maximale : Profondeur de recherche maximale (par défaut : 2)
• planner_provider: : fournisseur de modélisation pour la phase de planification (par défaut : "openai", optionnel "groq")
• planner_model: : Modèle spécifique utilisé pour la planification (par défaut : "o3-mini", optionnellement "deepseek-r1-distill-llama-70b").
• writer_model: : Modèle utilisé pour écrire le rapport (par défaut : "claude-3-5-sonnet-latest")
• search_api: API de recherche utilisée (par défaut : Tavily)