← Back to directory
L

Local Deep Research (LDR) MCP Server

Official
Local-first deep research assistant exposing multi-engine search and cited reports to Claude over MCP.
Category
Other #10 of 230
Stars
★ 9.5k Very popular
Transport
stdio (local process)
Runtime
Python · Docker
Credentials
Optional API key
License
MIT
Last commit
Tools
8
70FMRS · B

LDR's MCP server is the project's own official integration, exposing its multi-engine search, private-document analysis, and cited report generation through 8 tools over local STDIO transport. It's compelling for privacy-focused users who already run local or cloud LLMs and search infrastructure, but the docs are explicit that the server lacks authentication and rate limiting and is meant for local, single-machine use rather than network deployment.

Strongest · Maintenance 18/20 Weakest · Reliability 9/20

Reliability
9/20
Security and permissions
14/20
Maintenance
18/20
Documentation
17/20
Setup experience
12/20
Why each score
Reliability 9/20
The README lists the MCP tool surface (search, quick_research, detailed_research, generate_report, analyze_documents, list_search_engines, list_strategies, get_configuration) with plausible duration/cost annotations, which is a reasonably specific behavioral claim. However, no server manifest was available for this review ('not cached'), so the declared tool schemas/parameters could not be cross-checked against actual server behavior. The repo carries many CI badges (CodeQL, Semgrep, pre-commit, security-tests, etc.), but these target the main web app and container security rather than the MCP STDIO handshake, tool-call path, or error handling specifically — no committed tests demonstrably cover MCP-specific key paths. Per the static calibration rule, reliability is capped at 12 absent manifest and MCP-path test evidence; the missing manifest and thin MCP-specific test evidence bring the score to 9.
Security and permissions 14/20
The MCP server is explicitly scoped to local STDIO use (Claude Desktop/Claude Code) and the README candidly warns it has 'no built-in authentication or rate limiting' and should not be exposed to a network without added controls — this disclosure is a positive signal and is a reasonable design for a local single-user tool, not a red-line issue. The broader application shows strong security posture: SQLCipher AES-256 per-user encrypted databases, passwords never stored, Cosign-signed and digest-pinned Docker images with SLSA provenance and SBOMs, cap_drop ALL / non-root runtime, and a detailed SECURITY.md with documented scanner-suppression rationale. Deductions: the MCP client config examples pass LLM API keys as plaintext environment variables in local config files (standard MCP practice but still a local credential-exposure surface), and the README's own 'in-memory credentials' section acknowledges runtime secret exposure as an inherent risk (with stated mitigations). No irreversible destructive/auto-pay/auto-deploy defaults were found, so this does not qualify as a red line. Overall: 14.
Maintenance 18/20
The project shows 8,849 stars, active commit-activity and last-commit badges, and an extensive CI/CD security pipeline (CodeQL, Semgrep, DevSkim, Bearer, OSV-Scanner, npm-audit, Retire.js, Dockle, Hadolint, Checkov, Zizmor, OWASP ZAP, etc.), plus a documented security review process, SECURITY.md, CONTRIBUTING.md, a release guide, and CI/CD infrastructure docs — indicating clear ownership and governance. Open issue count (312) is on the higher side but plausible for a project of this scale and activity level, and there are active community channels (Discord, Reddit). License is clearly MIT. This reflects sustained, well-governed maintenance, warranting 18.
Documentation 17/20
Documentation is layered and broad: installation guide, FAQ, API quickstart, configuration guide plus an auto-generated full configuration reference, features guide, search-engines guide, analytics dashboard docs, benchmarking guide, LangChain integration guide, and a dedicated MCP Server guide (docs/mcp-server.md, linked but not supplied in full for this review). The MCP tools table gives name, description, duration range, and LLM cost — practically useful for decision-making — alongside concrete Claude Desktop/Claude Code JSON config examples. The upgrade notes (e.g., 1.6.3 default-model removal, auto/parallel engine removal, llamacpp's move to HTTP mode) show honest disclosure of breaking changes. Deduction: the MCP-specific guide content itself was not available for direct verification, and detailed parameter limits/troubleshooting evidence for MCP tools is incomplete, so this stops short of full marks at 17.
Setup experience 12/20
Clear step-by-step instructions are given: pip install "local-deep-research[mcp]", followed by concrete JSON configuration examples for both Claude Desktop and Claude Code, including environment-variable-based LLM provider configuration. However, per the static calibration rule, setup is capped at 15 absent verifiable execution evidence (real CI workflows plus committed tests covering the server's key paths). Additionally, real usability requires further configuring an LLM backend (Ollama/OpenAI-compatible endpoint, etc.) and a search engine (e.g., SearXNG), adding multi-step complexity and external dependencies; the README itself flags a known Docker Desktop '--network host' pitfall requiring a FAQ lookup. Combined, this yields 12.

Static review · not runListed 2026-08-06

Read the FMRS scoring method →

Fit and risk

What it can accessReads local filesUses the networkConnects to a database

Best for

  • Privacy-conscious researchers and developers who want to run LLMs and search fully locally
  • Users already running local models via Ollama, LM Studio, or llama.cpp
  • People who want to give Claude multi-engine academic search and structured report generation
  • Local, STDIO-based integration into Claude Desktop or Claude Code

Not for

  • Multi-user or network-exposed deployments — this MCP server has no built-in authentication or rate limiting and is documented as local-use only
  • Users wanting a zero-config tool — it requires configuring an LLM provider and a search engine, and sometimes deploying SearXNG
  • Teams needing real-time multi-user collaboration features

Required permissions

  • Access to a configured LLM (local endpoint or cloud API key)
  • Outbound network access to call configured search engines (arXiv, PubMed, SearXNG, Brave, etc.), unless restricted to local documents only
  • Local filesystem read access for analyze_documents to work with private documents
  • Read/write access to the local encrypted (SQLCipher) database

Risks and side effects

  • The docs explicitly warn this MCP server is designed for local use only via STDIO transport, has no built-in authentication or rate limiting, and should not be exposed over a network without additional security controls
  • Credentials (e.g. API keys) are held in process memory during active sessions, a routine runtime risk the project mitigates with session-scoped credential lifetimes and core dump exclusion
  • Research queries are sent to whichever search engines are configured, and cloud LLM providers (OpenAI, Anthropic, Google, etc.) receive query/document content when selected
  • Docker's --network host mode can silently fail to expose ports or misroute localhost on Windows/WSL2/Mac

Setup

Before you start

Runtime:Python · Docker

LDR_LLM_PROVIDER required Selects the LLM provider, e.g. openai or ollama, set in the MCP client's env config.
LDR_LLM_OPENAI_API_KEY optionalsecret OpenAI API key required when using the openai provider; obtain it at platform.openai.com.
Other optional settings (1)
LDR_LLM_OLLAMA_URL optional Ollama server URL (default http://localhost:11434), set when using a local Ollama instance.

1) Install the package with MCP extras: pip install "local-deep-research[mcp]"; 2) set up an LLM source (local Ollama/LM Studio/llama.cpp, or a cloud provider API key for OpenAI/Anthropic/Google/etc.); 3) add an mcpServers entry to claude_desktop_config.json (Claude Desktop) or .mcp.json / ~/.claude/mcp.json (Claude Code) with command set to ldr-mcp and any needed LDR_* variables passed via env (e.g. LDR_LLM_PROVIDER, LDR_LLM_OLLAMA_URL, LDR_LLM_OPENAI_API_KEY); 4) restart the Claude client to pick up the config; for web search, also run SearXNG or another configured search engine.

claude_desktop_config.json
{
  "mcpServers": {
    "local-deep-research": {
      "command": "ldr-mcp",
      "env": {
        "LDR_LLM_PROVIDER": "openai",
        "LDR_LLM_OPENAI_API_KEY": "sk-..."
      }
    }
  }
}

Shown for Claude Desktop. Other clients may use a different file or key (VS Code uses "servers") — the configurator below converts it.

.vscode/mcp.json
{
  "servers": {
    "local-deep-research": {
      "command": "ldr-mcp",
      "env": {
        "LDR_LLM_PROVIDER": "openai",
        "LDR_LLM_OPENAI_API_KEY": "sk-..."
      }
    }
  }
}

Goes in your project's .vscode/mcp.json (VS Code uses a "servers" key).

Terminal
claude mcp add local-deep-research -e LDR_LLM_PROVIDER=openai -e LDR_LLM_OPENAI_API_KEY=sk-... -- ldr-mcp

Run it in a terminal; replace any <…> placeholders with your own values first.

Check that it works

After pip install "local-deep-research[mcp]" and configuring the client, confirm the 8 tools (search, quick_research, detailed_research, generate_report, analyze_documents, list_search_engines, list_strategies, get_configuration) appear in the client's tool list; calling list_search_engines and getting a result proves the connection works.

Troubleshooting

  1. Confirm pip install "local-deep-research[mcp]" was run so the ldr-mcp command exists
  2. Check that the mcpServers env block sets LDR_LLM_PROVIDER and the matching URL/API key (e.g. LDR_LLM_OLLAMA_URL, LDR_LLM_OPENAI_API_KEY)
  3. Verify the local LLM service (Ollama, LM Studio, or llama-server) is running and reachable on its default port
  4. For web search, confirm SearXNG or another search engine is running and reachable; use list_search_engines to check
  5. Consult docs/mcp-server.md and docs/CONFIGURATION.md in the repo for the full list of LDR_* environment variables
  6. If using Docker on Windows/WSL2 and port 5000 isn't reachable, see the docs/faq.md entry and switch to the Docker Compose setup

Things to try

Once connected, you can ask your AI assistant things like:

  • Use search on arxiv for recent papers on diffusion models
  • Use quick_research to find information about quantum computing applications
  • Generate a detailed research report on renewable energy trends
  • Use analyze_documents to search my local documents for deployment procedures

Tools 8

search read-only
Queries a specific search engine directly (e.g. arxiv, pubmed, wikipedia) and returns raw title/link/snippet results with no LLM processing — fast and free, useful for monitoring and subscriptions.
quick_research read-only
Produces a fast, cited research summary for a question. Takes about 1-5 minutes and incurs LLM cost.
detailed_research read-only
Runs a comprehensive multi-source analysis with structured findings. Takes about 5-15 minutes and incurs LLM cost.
generate_report read-only
Generates a full Markdown research report with sections and a table of contents. Takes about 10-30 minutes and incurs LLM cost.
analyze_documents read-only
Searches the user's imported private document collections. Takes about 30 seconds to 2 minutes and incurs LLM cost.
list_search_engines read-only
Lists the search engines currently available. Returns instantly with no LLM cost.
list_strategies read-only
Lists the available research strategies (e.g. langgraph-agent). Returns instantly with no LLM cost.
get_configuration read-only
Returns the current LDR configuration. Returns instantly with no LLM cost.

Use cases

Research academic papers (arXiv, PubMed, Semantic Scholar) directly from Claude
Generate cited quick-answer summaries or full research reports
Semantically search and analyze a private document collection
Use the search tool for low-cost, LLM-free monitoring/subscription-style checks

Supported clients

Claude Desktop
Claude Code

Listed from the project's documentation, not tested by this site.

Overview

Local Deep Research (LDR) is an open-source AI research assistant that runs local LLMs (Ollama, LM Studio, llama.cpp) or cloud models (OpenAI, Anthropic, Google, and more), searches across 10+ engines (arXiv, PubMed, Semantic Scholar, SearXNG, GitHub, etc.) plus a user's own private documents, and synthesizes findings into cited summaries or full reports. User data lives in a per-user, AES-256-encrypted SQLCipher database, with passwords never stored. The same repository ships an MCP server so Claude Desktop and Claude Code can drive these research capabilities directly; the docs state it is designed strictly for local use via STDIO transport, with no built-in authentication or rate limiting.

Similar servers

BioMCP 75 · B

One binary. One grammar. Evidence from the biomedical sources you already trust.

★ 672 · Tools 11 Compare with this →

Source revision c1e570b8dc7c Data synced 2026-11-04 Read the FMRS scoring method