open_deep_research

Tue, 22 Jul 2025 15:33:16 +0800

langchain-ai/open_deep_research

Open Deep Research

Deep research has broken out as one of the most popular agent applications. This is a simple, configurable, fully open source deep research agent that works across many model providers, search tools, and MCP servers.

Read more in our blog
See our video for a quick overview

🚀 Quickstart

Clone the repository and activate a virtual environment:

git clone https://github.com/langchain-ai/open_deep_research.git
cd open_deep_research
uv venv
source .venv/bin/activate  # On Windows: .venv\Scripts\activate

Install dependencies:

`1`	`uv pip install -r pyproject.toml`

Set up your .env file to customize the environment variables (for model selection, search tools, and other configuration settings):

`1`	`cp .env.example .env`

Launch the assistant with the LangGraph server locally to open LangGraph Studio in your browser:

1
2

# Install dependencies and start the LangGraph server
uvx --refresh --from "langgraph-cli[inmem]" --with-editable . --python 3.11 langgraph dev --allow-blocking

Use this to open the Studio UI:

1
2
3

- 🚀 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

Ask a question in the messages input field and click Submit.

Configurations

Open Deep Research offers extensive configuration options to customize the research process and model behavior. All configurations can be set via the web UI, environment variables, or by modifying the configuration directly.

General Settings

Max Structured Output Retries (default: 3): Maximum number of retries for structured output calls from models when parsing fails
Allow Clarification (default: true): Whether to allow the researcher to ask clarifying questions before starting research
Max Concurrent Research Units (default: 5): Maximum number of research units to run concurrently using sub-agents. Higher values enable faster research but may hit rate limits

Research Configuration

Search API (default: Tavily): Choose from Tavily (works with all models), OpenAI Native Web Search, Anthropic Native Web Search, or None
Max Researcher Iterations (default: 3): Number of times the Research Supervisor will reflect on research and ask follow-up questions
Max React Tool Calls (default: 5): Maximum number of tool calling iterations in a single researcher step

Models

Open Deep Research uses multiple specialized models for different research tasks:

Summarization Model (default: openai:gpt-4.1-nano): Summarizes research results from search APIs
Research Model (default: openai:gpt-4.1): Conducts research and analysis
Compression Model (default: openai:gpt-4.1-mini): Compresses research findings from sub-agents
Final Report Model (default: openai:gpt-4.1): Writes the final comprehensive report

All models are configured using init_chat_model() API which supports providers like OpenAI, Anthropic, Google Vertex AI, and others.

Important Model Requirements:

Structured Outputs: All models must support structured outputs. Check support here.
Search API Compatibility: Research and Compression models must support your selected search API:
- Anthropic search requires Anthropic models with web search capability
- OpenAI search requires OpenAI models with web search capability
- Tavily works with all models
Tool Calling: All models must support tool calling functionality
Special Configurations:
- For OpenRouter: Follow this guide
- For local models via Ollama: See setup instructions

Example MCP (Model Context Protocol) Servers

Open Deep Research supports MCP servers to extend research capabilities.

Local MCP Servers

Filesystem MCP Server provides secure file system operations with robust access control:

Read, write, and manage files and directories
Perform operations like reading file contents, creating directories, moving files, and searching
Restrict operations to predefined directories for security
Support for both command-line configuration and dynamic MCP roots

Example usage:

`1`	`mcp-server-filesystem /path/to/allowed/dir1 /path/to/allowed/dir2`

Remote MCP Servers

Remote MCP servers enable distributed agent coordination and support streamable HTTP requests. Unlike local servers, they can be multi-tenant and require more complex authentication.

Arcade MCP Server Example:

{
  "url": "https://api.arcade.dev/v1/mcps/ms_0ujssxh0cECutqzMgbtXSGnjorm",
  "tools": ["Search_SearchHotels", "Search_SearchOneWayFlights", "Search_SearchRoundtripFlights"]
}

Remote servers can be configured as authenticated or unauthenticated and support JWT-based authentication through OAuth endpoints.

Evaluation

A comprehensive batch evaluation system designed for detailed analysis and comparative studies.

Features:

Multi-dimensional Scoring: Specialized evaluators with 0-1 scale ratings
Dataset-driven Evaluation: Batch processing across multiple test cases

Usage:

1
2

# Run comprehensive evaluation on LangSmith datasets
python tests/run_evaluate.py

Key Files:

tests/run_evaluate.py: Main evaluation script
tests/evaluators.py: Specialized evaluator functions
tests/prompts.py: Evaluation prompts for each dimension

Deployments and Usages

LangGraph Studio

Follow the quickstart to start LangGraph server locally and test the agent out on LangGraph Studio.

Hosted deployment

You can easily deploy to LangGraph Platform.

Open Agent Platform

Open Agent Platform (OAP) is a UI from which non-technical users can build and configure their own agents. OAP is great for allowing users to configure the Deep Researcher with different MCP tools and search APIs that are best suited to their needs and the problems that they want to solve.

We’ve deployed Open Deep Research to our public demo instance of OAP. All you need to do is add your API Keys, and you can test out the Deep Researcher for yourself! Try it out here

You can also deploy your own instance of OAP, and make your own custom agents (like Deep Researcher) available on it to your users.

Updates 🔥

Legacy Implementations 🏛️

The src/legacy/ folder contains two earlier implementations that provide alternative approaches to automated research:

1. Workflow Implementation (`legacy/graph.py`)

Plan-and-Execute: Structured workflow with human-in-the-loop planning
Sequential Processing: Creates sections one by one with reflection
Interactive Control: Allows feedback and approval of report plans
Quality Focused: Emphasizes accuracy through iterative refinement

2. Multi-Agent Implementation (`legacy/multi_agent.py`)

Supervisor-Researcher Architecture: Coordinated multi-agent system
Parallel Processing: Multiple researchers work simultaneously
Speed Optimized: Faster report generation through concurrency
MCP Support: Extensive Model Context Protocol integration

See src/legacy/legacy.md for detailed documentation, configuration options, and usage examples for both legacy implementations.

langchain4j

Sun, 08 Jun 2025 15:28:32 +0800

langchain4j/langchain4j

LangChain for Java: Supercharge your Java application with the power of LLMs

Introduction

Welcome!

The goal of LangChain4j is to simplify integrating LLMs into Java applications.

Here’s how:

Unified APIs: LLM providers (like OpenAI or Google Vertex AI) and embedding (vector) stores (such as Pinecone or Milvus) use proprietary APIs. LangChain4j offers a unified API to avoid the need for learning and implementing specific APIs for each of them. To experiment with different LLMs or embedding stores, you can easily switch between them without the need to rewrite your code. LangChain4j currently supports 15+ popular LLM providers and 15+ embedding stores.
Comprehensive Toolbox: Since early 2023, the community has been building numerous LLM-powered applications, identifying common abstractions, patterns, and techniques. LangChain4j has refined these into practical code. Our toolbox includes tools ranging from low-level prompt templating, chat memory management, and function calling to high-level patterns like Agents and RAG. For each abstraction, we provide an interface along with multiple ready-to-use implementations based on common techniques. Whether you’re building a chatbot or developing a RAG with a complete pipeline from data ingestion to retrieval, LangChain4j offers a wide variety of options.
Numerous Examples: These examples showcase how to begin creating various LLM-powered applications, providing inspiration and enabling you to start building quickly.

LangChain4j began development in early 2023 amid the ChatGPT hype. We noticed a lack of Java counterparts to the numerous Python and JavaScript LLM libraries and frameworks, and we had to fix that! Although “LangChain” is in our name, the project is a fusion of ideas and concepts from LangChain, Haystack, LlamaIndex, and the broader community, spiced up with a touch of our own innovation.

We actively monitor community developments, aiming to quickly incorporate new techniques and integrations, ensuring you stay up-to-date. The library is under active development. While some features are still being worked on, the core functionality is in place, allowing you to start building LLM-powered apps now!

Documentation

Documentation can be found here.

The documentation chatbot (experimental) can be found here.

Getting Started

Getting started guide can be found here.

Code Examples

Please see examples of how LangChain4j can be used in langchain4j-examples repo:

Examples in plain Java
Examples with Quarkus (uses quarkus-langchain4j dependency)
Example with Spring Boot
Examples with Helidon (uses io.helidon.integrations.langchain4j dependency)
Examples with Micronaut (uses micronaut-langchain4j dependency)

Useful Materials

Useful materials can be found here.

Get Help

Please use Discord or GitHub discussions to get help.

Request Features

Please let us know what features you need by opening an issue.

Contribute

Contribution guidelines can be found here.

Google Vertex AI on Producthunt daily