local-deep-research

AI research assistant you control. Run locally for privacy, use any LLM and build your own searchable knowledge base. You own your data and see exactly how it works.

Option 1: Docker Run (Linux)

# Step 1: Pull and run Ollama
docker run -d -p 11434:11434 --name ollama ollama/ollama
docker exec ollama ollama pull gpt-oss:20b

# Step 2: Pull and run SearXNG for optimal search results
docker run -d -p 8080:8080 --name searxng searxng/searxng

# Step 3: Pull and run Local Deep Research
# (the URL line pins SearXNG's address AND marks it operator-approved —
#  private/localhost engine URLs are otherwise blocked by default since
#  v1.10.3. The URL becomes read-only in the web UI; docs/SearXNG-Setup.md
#  lists the alternatives, e.g. an origin allowlist.)
docker run -d --network host \
  --name local-deep-research \
  --volume "deep-research:/data" \
  -e LDR_DATA_DIR=/data \
  -e LDR_SEARCH_ENGINE_WEB_SEARXNG_DEFAULT_PARAMS_INSTANCE_URL=http://localhost:8080 \
  localdeepresearch/local-deep-research

Mac / Windows / WSL2 users: --network host only works on native Linux. On Docker Desktop it silently fails to publish port 5000 and leaves localhost pointing at the LDR container itself (so it can't reach Ollama/SearXNG). Use Option 2 below, or see the Windows/WSL2 FAQ entry for a working docker run recipe.

Option 2: Docker Compose

CPU-only (all platforms):

curl -O https://raw.githubusercontent.com/LearningCircuit/local-deep-research/main/docker-compose.yml && docker compose up -d

With NVIDIA GPU (Linux):

curl -O https://raw.githubusercontent.com/LearningCircuit/local-deep-research/main/docker-compose.yml && \
curl -O https://raw.githubusercontent.com/LearningCircuit/local-deep-research/main/docker-compose.gpu.override.yml && \
docker compose -f docker-compose.yml -f docker-compose.gpu.override.yml up -d

Open http://localhost:5000 after ~30 seconds. For GPU setup, environment variables, and more, see the Docker Compose Guide.

Option 3: pip install

pip install local-deep-research
python -m local_deep_research.web.app   # starts the web UI on http://localhost:5000

You'll also need Ollama (or any OpenAI-compatible LLM endpoint) and SearXNG running — see the pip install guide for the full recipe. Works on Windows, macOS, and Linux. SQLCipher encryption is included via pre-built wheels — no compilation needed. PDF export on Windows requires Pango (setup guide). Development fallback: LDR_BOOTSTRAP_ALLOW_UNENCRYPTED=true permits plaintext SQLite only when SQLCipher is unavailable or nonfunctional; working SQLCipher still takes priority. The fallback does not verify account passwords and is unsuitable for shared deployments. See fallback limitations.

Detailed install guides: Docker · Docker Compose · pip · Unraid · full install reference

Older CPU (x86-64)? LDR needs an AVX-capable CPU — Intel Sandy Bridge / AMD Bulldozer (2011) or newer. Several scientific Python dependencies (pandas, scikit-learn) ship wheels that crash with Illegal instruction on older CPUs. ARM64 (aarch64) is fully supported. Every release is smoke-tested against this floor, including AVX-without-AVX2 CPUs (#4480).

You ask a complex question. Local Deep Research (LDR):

• Does the research for you automatically
• Searches across web, academic papers, and your own documents
• Synthesizes everything into a report with proper citations

Choose the research strategy that fits: quick pipeline modes for fast facts, or fully agentic deep research for complex analysis and academic work.

LangGraph Agent Strategy — An autonomous agentic research mode where the LLM decides what to search, which specialized engines to use (arXiv, PubMed, Semantic Scholar, etc.), and when to synthesize. It adaptively switches between search engines based on what it finds and collects significantly more sources than pipeline-based strategies — this is the strategy behind the ~95% SimpleQA result above. Select langgraph-agent in Settings.

flowchart LR
    R[Research] --> D[Download Sources]
    D --> L[(Library)]
    L --> I[Index & Embed]
    I --> S[Search Your Docs]
    S -.-> R

Every research session finds valuable sources. Download them directly into your encrypted library — academic papers from ArXiv, PubMed articles, web pages. LDR extracts text, indexes everything, and makes it searchable. Next time you research, ask questions across your own documents and the live web together. Your knowledge compounds over time.

flowchart LR
    U1[User A] --> D1[(Encrypted DB)]
    U2[User B] --> D2[(Encrypted DB)]

Your data stays yours. Each user gets their own isolated SQLCipher database encrypted with AES-256, with the key derived from your password. Your password is never stored — login works by attempting to decrypt your database, so the database files on their own are unusable to anyone who obtains them. Per-user LLM API keys live encrypted inside the same personal database rather than in a shared server-level store.

The Docker setup ships with cap_drop: ALL, no-new-privileges, and a non-root runtime, with the bundled Ollama and SearXNG images pinned by digest. With a model running in the bundled Ollama, inference runs on your own hardware. LDR judges locality mainly by provider and endpoint address, not by where the model runs, so a local endpoint that relays to a hosted model (an Ollama cloud model, or a local LiteLLM or other OpenAI-compatible proxy in front of a hosted API) can still send your prompts off the machine without being detected. A self-hosted SearXNG still forwards your search queries to its upstream engines on the internet. To keep a run on private sources, search only local sources (collections, your library) under the Private only egress scope described below. That scope is a best-effort guard rail, not an air gap: see the Egress control section below and SECURITY.md.

In-memory credentials: Like any application that uses secrets at runtime, credentials are held in process memory during active sessions — mitigated with session-scoped credential lifetimes and core dump exclusion. See the Security Policy for the full threat model.

Supply Chain Security: Docker images are signed with Cosign using GitHub's keyless OIDC flow, include SLSA provenance attestations, and ship with attested SPDX SBOMs. See Verifying images and SBOMs for the step-by-step verification commands.

Security Transparency: Scanner suppressions are documented with justifications in Security Alerts Assessment, Scorecard Compliance, Container CVE Suppressions, and SAST Rule Rationale. Some alerts (Dependabot, code scanning) can only be dismissed or are very difficult to suppress outside the GitHub Security tab, so the files above do not cover every dismissed finding.

Detailed Architecture → | Security Policy → | Security Review Process →

Every research run has an egress scope that restricts, on a best-effort basis, where its traffic may go: which search engines run, whether the LLM and embeddings may be cloud services, and which result URLs may be fetched. Set it under Settings → Egress Scope or in the Privacy & Egress panel on the research form; choosing a scope in the panel also saves it as your default setting, so later runs use it too.

Strict and Private only (including an Adaptive run that resolves to it) also arm a best-effort socket-level guard on the research run that normally refuses connections to public addresses. It is a backstop with known gaps, not a guarantee; the Strict section of Egress modes lists some of them, such as a forward proxy or a relay on a private address. Under Strict, public engines, public result fetches and cloud model calls therefore usually fail, so pair it with a local engine and local models.

A locally-hosted SearXNG counts as a public engine — it proxies searches to the internet — so it is not available under Private only. Under Strict it may still run as your primary engine, and it then forwards your queries to its upstream engines on the internet.

LDR's guarded HTTP layer, used for most search-result and document fetches, also checks destinations against SSRF rules (including known cloud-metadata addresses such as 169.254.169.254) and re-checks redirects. With JavaScript rendering enabled (web.enable_javascript_rendering, off by default), pages that need it are loaded in headless Chromium, which resolves addresses itself. See the egress module README for the details.

Whether a signed-in user can point a search engine at a private address depends on the kind of engine:

• Public engines with a configurable address (currently SearXNG): a private or loopback URL is normally refused unless the operator opts in through the environment (LDR_SEARCH_ALLOW_PRIVATE_ENGINE_URLS=true, an exact origin in LDR_SEARCH_PRIVATE_ENGINE_URL_ALLOWLIST, or pinning the URL itself with LDR_SEARCH_ENGINE_WEB_SEARXNG_DEFAULT_PARAMS_INSTANCE_URL). A SearXNG on localhost therefore normally needs one of these.
• Local document-store engines (Paperless-ngx and Elasticsearch): their address settings, search.engine.web.paperless.default_params.api_url and search.engine.web.elasticsearch.default_params.hosts, are meant to point at private hosts, so currently no opt-in applies: any signed-in user can set them to an internal address and the server will connect to it. If that is not acceptable, pin these settings with their environment variables (LDR_ plus the key in upper case with dots replaced by underscores, for example LDR_SEARCH_ENGINE_WEB_PAPERLESS_DEFAULT_PARAMS_API_URL), or lock settings changes with LDR_APP_LOCK_SETTINGS=true.

The egress policy is an in-process guard rail against misconfiguration and prompt-injected fetches, not an air gap or a hard security boundary: for example, hostnames are still resolved through the configured DNS resolver before a fetch is refused, and it cannot reliably constrain code that runs inside the LDR process. For a hard boundary, add egress filtering at the container or firewall level as well.

Egress modes → | Threat model and caveats → | Enforcement points →

Local Deep Research contains no telemetry, no analytics, and no tracking. We do not collect, transmit, or store any data about you or your usage. No analytics SDKs, no phone-home calls, no crash reporting, no external scripts. Usage metrics stay in your local encrypted database.

The only network calls LDR makes are ones you initiate: search queries (to engines you configure), LLM API calls (to your chosen provider), and notifications (only if you set up Apprise).

Since we don't collect any usage data, we rely on you to tell us what works, what's broken, and what you'd like to see next — bug reports, feature ideas, and even which features you love or never use all help us improve LDR.

Headline results from the community benchmarks using the langgraph-agent strategy with Serper (cloud) search and the models running locally in Ollama:

Caveats: small samples, LLM-grader noise, and SimpleQA contamination risk on newer base models.

Picking a local model? The same community-maintained dataset tracks accuracy across models, search engines, and research strategies — the fastest way to see which Ollama / LM Studio / llama.cpp models actually work well for deep research before you download multi-GB weights. Browse the full leaderboard on Hugging Face →

Submit your own results → (contributors are listed in CONTRIBUTORS.md), or run benchmarks locally →.

• Quick Summary - Get answers in 30 seconds to 3 minutes with citations
• Detailed Research - Comprehensive analysis with structured findings
• Report Generation - Professional reports with sections and table of contents
• Document Analysis - Search your private documents with AI

• LangChain Integration - Use any vector store as a search engine
• REST API - Authenticated HTTP access with per-user databases
• Benchmarking - Test and optimize your configuration
• Analytics Dashboard - Track costs, performance, and usage metrics
• Journal Quality System - Automatic journal reputation scoring with 212K+ indexed sources, predatory detection, and quality dashboard. Powered by OpenAlex (CC0), DOAJ (CC0), and Stop Predatory Journals (MIT). See the v1.6.0 announcement.
• Real-time Updates - WebSocket support for live research progress
• Chat Mode - Multi-turn research conversations with streaming progress and accumulated context across turns
• Export Options - Download results as PDF or Markdown
• Research History - Save, search, and revisit past research
• Adaptive Rate Limiting - Intelligent retry system that learns optimal wait times
• Keyboard Shortcuts - Navigate efficiently (ESC, Ctrl+Shift+1-4)

• Automated Research Digests - Subscribe to topics or specific queries; AI filters and summarizes only the most relevant developments
• Customizable Delivery - Daily, weekly, or custom schedules, as markdown reports or structured summaries

• Academic: arXiv, PubMed, Semantic Scholar
• General: Wikipedia, SearXNG
• Technical: GitHub, Elasticsearch
• Archived pages: Wayback Machine URL fetching
• News: The Guardian, Wikinews

• Tavily - AI-powered search
• Google - Via SerpAPI or Programmable Search Engine
• Brave Search - Privacy-focused web search

• Local Documents - Search your files with AI
• LangChain Retrievers - Any vector store or database
• Meta Search - Combine multiple engines intelligently

LDR respects robots.txt and identifies itself honestly when fetching web pages — no stealth or anti-detection techniques. In rare cases this means a page that blocks automated access won't be fetched, which we consider the right trade-off.

Full Search Engines Guide →

from local_deep_research.api import LDRClient, quick_query

# Option 1: Simplest - one line research
summary = quick_query("username", "password", "What is quantum computing?")
print(summary)

# Option 2: Client for multiple operations
client = LDRClient()
client.login("username", "password")
result = client.quick_research("What are the latest advances in quantum computing?")
print(result["summary"])

The code example below shows the basic API structure - for working examples, see the link below

import requests
from bs4 import BeautifulSoup

# Create session and authenticate
session = requests.Session()
login_page = session.get("http://localhost:5000/auth/login")
soup = BeautifulSoup(login_page.text, "html.parser")
login_csrf = soup.find("input", {"name": "csrf_token"}).get("value")

# Login and get API CSRF token
session.post("http://localhost:5000/auth/login",
            data={"username": "user", "password": "pass", "csrf_token": login_csrf})
csrf = session.get("http://localhost:5000/auth/csrf-token").json()["csrf_token"]

# Make API request
response = session.post("http://localhost:5000/api/start_research",
                       json={"query": "Your research question"},
                       headers={"X-CSRF-Token": csrf})

🚀 Ready-to-use HTTP API Examples → examples/api_usage/http/

• ✅ Automatic user creation - works out of the box
• ✅ Complete authentication with CSRF handling
• ✅ Result retry logic - waits until research completes
• ✅ Progress monitoring and error handling

# Run benchmarks from CLI
python -m local_deep_research.benchmarks.cli.benchmark_commands simpleqa --examples 50

See the Command Line Tools guide for the full reference.

Connect LDR to your existing knowledge base. Unlike the HTTP client above, quick_summary() runs LDR in-process — no server needed — so you can pass it live Python objects such as LangChain retrievers:

from local_deep_research.api import quick_summary

# Use your existing LangChain retriever
result = quick_summary(
    query="What are our deployment procedures?",
    retrievers={"company_kb": your_retriever},
    search_tool="company_kb"
)

Works with: FAISS, Chroma, Pinecone, Weaviate, Elasticsearch, and any LangChain-compatible retriever.

Integration Guide →

LDR provides an MCP (Model Context Protocol) server that allows AI assistants like Claude Desktop and Claude Code to perform deep research. Full setup details in the MCP Server guide.

⚠️ Security Note: This MCP server is designed for local use only via STDIO transport (e.g., Claude Desktop). It has no built-in authentication or rate limiting. Do not expose over a network without implementing proper security controls. See the MCP Security Best Practices for network deployment requirements.

# Install with MCP extras
pip install "local-deep-research[mcp]"

Add to your claude_desktop_config.json:

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

Add to your .mcp.json (project-level) or ~/.claude/mcp.json (global):

{
  "mcpServers": {
    "local-deep-research": {
      "command": "ldr-mcp",
      "env": {
        "LDR_LLM_PROVIDER": "ollama",
        "LDR_LLM_OLLAMA_URL": "http://localhost:11434"
      }
    }
  }
}

Any LDR setting can be passed in env as an LDR_* variable — see the auto-generated Full Configuration Reference for the complete list.

The search tool lets you query specific search engines directly and get raw results (title, link, snippet) — no LLM processing, no cost, fast. This is especially useful for monitoring and subscriptions where you want to check for new content regularly without burning LLM tokens.

# Search arXiv for recent papers
search(query="transformer architecture improvements", engine="arxiv")

# Search PubMed for medical literature
search(query="CRISPR clinical trials 2024", engine="pubmed")

# Search Wikipedia for quick facts
search(query="quantum error correction", engine="wikipedia")

# Search GitHub for code and repositories
search(query="agentic research frameworks", engine="github")

# Use list_search_engines() to see all available engines

"Use quick_research to find information about quantum computing applications"
"Search arxiv for recent papers on diffusion models"
"Generate a detailed research report on renewable energy trends"

• Ollama — connect to its native API (default http://localhost:11434)
• LM Studio — connect to its OpenAI-compatible server (default http://localhost:1234/v1)
• llama.cpp — connect to llama-server's OpenAI-compatible endpoint (default http://localhost:8080/v1); start with llama-server -m <model.gguf>
• Common models: Llama, Mistral, Gemma, DeepSeek, Qwen
• LLM processing runs on your own hardware when the model itself runs locally (search queries still go to the web). A local endpoint that relays to a hosted model, such as an Ollama cloud model or a local LiteLLM proxy, is not detected as remote. No API costs for locally-run models.

💡 Which local model should I pick? See the community benchmarks — community-submitted accuracy numbers across local and cloud models, so you can compare before downloading.

• OpenAI
• Anthropic Claude
• Google Gemini
• 100+ models via OpenRouter
• 100+ models via Requesty

• OpenAI-Compatible Endpoint — any service speaking the OpenAI chat-completions API (vLLM, llama.cpp, gateways)
• Anthropic-Compatible Endpoint — a self-hosted service speaking the Anthropic Messages API (/v1/messages); set llm.anthropic_endpoint.url

Model Setup →

For the first FastAPI-based major release, read the upgrade and rollback guide before updating. Back up the data first: the release's new database revisions prevent a direct rollback to v1.10.7 against the upgraded databases. Copy each user's automatic pre-migration backup from encrypted_databases/backups/ to storage outside the data directory immediately after that user's first sign-in on the new release, and in any case before any downgrade attempt: a login backup on a later UTC day or a password change replaces it with a copy of the upgraded database. Never start v1.10.7 against the upgraded databases: each sign-in attempt there also replaces that backup.

• llm.model no longer has a default. Pre-1.6.3 installs auto-filled gemma3:12b (Ollama) when no model was configured, which silently downloaded a multi-GB binary. The field is now empty by default — pick a model in Settings → LLM, or research will fail loudly with a clear error.

• The auto and parallel meta search engines were removed. The default langgraph-agent strategy selects engines dynamically per query, which replaces them. Stored settings are migrated automatically (removed values become searxng); update any explicit search_tool="auto" API calls or LDR_SEARCH_TOOL=auto env overrides to a concrete engine such as searxng.

• Behind a reverse proxy: the rate limiter reads the client address differently. Up to v1.10.7 the login and registration rate limits keyed on the left-most X-Forwarded-For entry, or else X-Real-IP, sent by any peer, so any client could choose its own bucket. What happens now depends on your configuration:

  • TRUST_PROXY_HEADERS unset (the default): those headers are read only when the direct peer is a private, loopback or link-local address (6to4, Teredo and NAT64 tunnel addresses do not count), or, once you set LDR_SERVER_FORWARDED_ALLOW_IPS to your proxy's address(es), only when it is listed there. The key is the right-most X-Forwarded-For entry, or X-Real-IP when no X-Forwarded-For is present.
  • TRUST_PROXY_HEADERS=true with LDR_SERVER_FORWARDED_ALLOW_IPS set to your proxy's address(es): forwarded headers count only from a listed peer. uvicorn derives the client address from a listed peer's X-Forwarded-For, and X-Real-IP (used when no X-Forwarded-For is present) is read only from a listed peer. Any other peer is keyed on its own address.
  • TRUST_PROXY_HEADERS=true without LDR_SERVER_FORWARDED_ALLOW_IPS: the key is the right-most X-Forwarded-For entry sent by any peer, public addresses included. That stops a client behind one appending proxy from choosing its bucket with a forged prefix, but a client that connects straight to LDR writes the whole header and still chooses its own key. X-Real-IP is read only from a private, loopback or link-local peer. LDR logs a startup warning for this configuration: set LDR_SERVER_FORWARDED_ALLOW_IPS.

  What it means for an existing proxy setup:

  • Proxy reaching LDR from a public or carrier-grade-NAT address (a cloud load balancer, a Tailscale 100.64.x.x peer, a public nginx host): without TRUST_PROXY_HEADERS its forwarded headers are now ignored; with TRUST_PROXY_HEADERS=true and no allow-list its X-Real-IP is ignored, while its X-Forwarded-For still counts. When the header your proxy sends is ignored, every client shares the proxy's one rate-limit bucket and a few failed logins lock everyone out. Set LDR_SERVER_FORWARDED_ALLOW_IPS to the proxy's IP address(es).
  • Proxy on a private or Docker network: (if you set a restricted LDR_SERVER_FORWARDED_ALLOW_IPS, only listed peers are trusted, so list this private proxy too.) With a single proxy, clients keep separate buckets, provided the proxy overwrites X-Forwarded-For with the address it observed (nginx: $remote_addr) and overwrites X-Real-IP the same way. A proxy that passes a client-sent header through unchanged still lets that client choose its key; a proxy that sets only X-Real-IP must also clear X-Forwarded-For, because LDR prefers it. Appending ($proxy_add_x_forwarded_for) gives the right rate-limit key, but under TRUST_PROXY_HEADERS=true without LDR_SERVER_FORWARDED_ALLOW_IPS uvicorn reports the left-most, client-written entry as the client address.
  • Two or more proxies in a chain (CDN → nginx): by default every client is keyed on the outer proxy's address, so all of them share one rate-limit bucket and a few failed logins lock everyone out. Either have the inner proxy resolve the real client itself (nginx realip) and overwrite with that address, or make every inner proxy append and set a multi-hop setting: LDR_SERVER_TRUSTED_PROXY_COUNT, or, with TRUST_PROXY_HEADERS=true, every hop listed in LDR_SERVER_FORWARDED_ALLOW_IPS. See Proxy chains.

  With TRUST_PROXY_HEADERS=true but no LDR_SERVER_FORWARDED_ALLOW_IPS, LDR logs a startup warning naming the variable (or refuses to start if LDR_SERVER_TRUSTED_PROXY_COUNT is also set to a positive value, or if the allow-list is set explicitly to * or another value that trusts every peer). See Reverse proxy configuration.

• The llamacpp provider now uses HTTP instead of in-process loading. If you previously set llm.llamacpp_model_path to a local .gguf file, that setting is no longer read. Instead, run llama-server -m <your-model.gguf> (it ships with every modern llama.cpp build) and the default llm.llamacpp.url of http://localhost:8080/v1 will pick it up. Optional API key support is available via llm.llamacpp.api_key if you put llama-server behind an auth proxy.

• Installation Guide
• Frequently Asked Questions
• API Quickstart
• Configuration Guide
• Full Configuration Reference

• All Features Guide
• Search Engines Guide
• Analytics Dashboard
• Incomplete Metrics Warning — Understand recording failures and missing metrics

• LangChain Integration
• Benchmarking System
• Elasticsearch Setup
• SearXNG Setup

• Docker Compose Guide
• Development Guide
• CodeQL Guide
• Release Guide
• CI/CD Infrastructure — pre-commit hooks, workflows, security scanning
• Workflow Status Dashboard — live health of every GitHub Actions workflow
• Test Coverage Report — pytest coverage published to GitHub Pages

• API Examples
• Benchmark Examples
• Optimization Examples

"Local Deep Research deserves special mention for those who prioritize privacy... tuned to use open-source LLMs that can run on consumer GPUs or even CPUs. Journalists, researchers, or companies with sensitive topics can investigate information without queries ever hitting an external server."

— Medium: Open-Source Deep Research AI Assistants

• Korben.info - French tech blog ("Sherlock Holmes numérique")
• Roboto.fr - "L'alternative open-source gratuite à Deep Research d'OpenAI"
• KDJingPai AI Tools - AI productivity tools coverage
• AI Sharing Circle - AI resources coverage

• r/LocalLLaMA: 95.7% SimpleQA on a single 3090, fully local - Qwen3.6-27B benchmark announcement (161K views)
• r/WebAfterAI: LDR as the agentic layer on top of Ollama / LM Studio / LocalAI - Stack-positioning explainer
• Hacker News - 190+ points, community discussion
• LangChain Twitter/X - Official LangChain promotion
• LangChain LinkedIn - 400+ likes

• Juejin (掘金) - Developer community
• Cnblogs (博客园) - Developer blogs
• GitHubDaily (Twitter/X) - Influential tech account
• Zhihu (知乎) - Tech community
• A姐分享 - AI resources
• CSDN - Installation guide
• NetEase (网易) - Tech news portal

• note.com: 調査革命：Local Deep Research徹底活用法 - Comprehensive tutorial
• Qiita: Local Deep Researchを試す - Docker setup guide
• LangChainJP (Twitter/X) - Japanese LangChain community

• PyTorch Korea Forum - Korean ML community
• GeekNews (Hada.io) - Korean tech news

• BSAIL Lab: How useful is Deep Research in Academia? - Academic review by contributor @djpetti
• The Art Of The Terminal: Use Local LLMs Already! - Comprehensive review of local AI tools, featuring LDR's research capabilities
• Fahd Mirza: Local Deep Research + Ollama — Free AI Research Assistant You Control - Installation walkthrough (349K-subscriber channel). The SearXNG startup issue shown in the video has since been fixed in #3881 — clean Docker installs now start out of the box.
• BC Adventure Tech: Run ChatGPT Deep Research Locally (Unraid AI Agent Setup) - Unraid setup and showcase

• SearXNG LDR-Academic - Academic-focused SearXNG fork with 12 research engines (arXiv, Google Scholar, PubMed, etc.) designed for LDR
• DeepWiki Documentation - Third-party documentation and guides

Note: Third-party projects and articles are independently maintained. We link to them as useful resources but cannot guarantee their code quality or security.

• Discord - Get help and share research techniques
• Reddit - Updates and showcases
• GitHub Issues - Bug reports

We welcome contributions of all sizes — from typo fixes to new features. The key rule: keep PRs small and atomic (one change per PR). You don't need to be assigned to an issue: comment that you're working on it and open an early (draft) PR so progress is visible. For hard or architectural changes, and for anything that could affect research results or benchmarks (LLM prompts, the advanced search system, search engines), outline your approach in the issue first, so your effort leads to a successful merge rather than a misaligned PR. See our Contributing Guide to get started.

Local Deep Research is built on the work of many open-access initiatives, academic databases, and open-source projects. We are grateful to:

Wikipedia • OpenLibrary • Project Gutenberg • GitHub • Stack Exchange • The Guardian • Wayback Machine

LangChain • Ollama • SearXNG • FAISS

These projects run on donations and grants, not paywalls. If Local Deep Research is useful to you, consider giving back to the open-access ecosystem that makes it possible:

• arXiv — free preprints for physics, math, CS, and more
• PubMed / NLM — open biomedical literature
• Wikipedia / Wikimedia — the free encyclopedia
• Internet Archive — the Wayback Machine and open digital library
• DOAJ — curating and verifying open-access journals worldwide
• OpenAlex — open scholarly metadata (sponsored by OurResearch)
• Project Gutenberg — free ebooks since 1971

MIT License - see LICENSE file.

Dependencies: All third-party packages use permissive licenses (MIT, Apache-2.0, BSD, etc.) - see allowlist