LearningCircuit/local-deep-researchPublic

~95% on SimpleQA (e.g. Qwen3.6-27B on a 3090). Supports all local and cloud LLMs (llama.cpp, Ollama, Google, ...). 10+ search engines - arXiv, PubMed, your private documents. Everything Local & Encrypted.

AI summary: Fully local, agentic AI assistant for deep web research with accurate citations on consumer hardware.

Stars
9.6K
+17 today
Forks
929
Watchers
38
Open issues
1.1K
Open PRs
351
Contributors
~115
Commits
8.8K
Branches
513

PythonMITCreated Feb 9, 2025Last push 3d agoLatest release v2.0.1+40 stars this week+344 this month

Quick answers

What is local-deep-research?
Fully local, agentic AI assistant for deep web research with accurate citations on consumer hardware.
What does local-deep-research do?
Local Deep Research is a privacy-first research tool that autonomously utilizes local LLMs and search engines to investigate complex topics. Unlike cloud-based alternatives that may expose sensitive data, it executes entirely on local hardware, capable of achieving state-of-the-art results on a single consumer GPU like an RTX 3090 using Qwen3.6-27B. The AI agent iteratively queries search engines such as SearXNG, reads the extracted content, synthesizes findings, and dynamically builds a searchable knowledge base. It ensures all data safely remains on the user's machine while systematically providing highly accurate, comprehensively cited reports.
Who is local-deep-research for?
Academemics, privacy-conscious professionals, and local-LLM enthusiasts who need deep research capabilities without cloud data exposure. Ideal for teams requiring efficient LLMs.
How do I get started with local-deep-research?
docker run -d -p 11434:11434 --name ollama ollama/ollama
How popular is local-deep-research on GitHub?
LearningCircuit/local-deep-research has 9,596 stars and 929 forks on GitHub, and gained 40 stars in the last 7 days.
What license does local-deep-research use?
LearningCircuit/local-deep-research is released under the MIT license.

Star history

since Jul 28, 2026
02.5K5K7.5KJul 2026Sep 2026Oct 2026Nov 2026
9.6K stars as of Nov 17, 2026. Measured daily since Jul 28, 2026; GitHub no longer exposes earlier star timestamps.

Update history

2 recorded
  • Nov 17, 2026New release v2.0.1 (previously v2.0.0).
  • Nov 10, 2026New release v2.0.0 (previously v1.10.7).

Contribution activity

commits per day, last 52 weeks
NovDecJanFebMarAprMayJunJulAugSepOctNovMonWedFri2025-11-23: 33 commits2025-11-24: 25 commits2025-11-25: 29 commits2025-11-26: 26 commits2025-11-27: 16 commits2025-11-28: 20 commits2025-11-29: 9 commits2025-11-30: 8 commits2025-12-01: 11 commits2025-12-02: 9 commits2025-12-03: 45 commits2025-12-04: 27 commits2025-12-05: 38 commits2025-12-06: 25 commits2025-12-07: 33 commits2025-12-08: 31 commits2025-12-09: 15 commits2025-12-10: 6 commits2025-12-11: 1 commit2025-12-12: 8 commits2025-12-13: 10 commits2025-12-14: 12 commits2025-12-15: 7 commits2025-12-16: 10 commits2025-12-17: 11 commits2025-12-18: 16 commits2025-12-19: 18 commits2025-12-20: 22 commits2025-12-21: 16 commits2025-12-22: 11 commits2025-12-23: 4 commits2025-12-24: 26 commits2025-12-25: 7 commits2025-12-26: 8 commits2025-12-27: 6 commits2025-12-28: 4 commits2025-12-29: 15 commits2025-12-30: 8 commits2025-12-31: 11 commits2026-01-01: 27 commits2026-01-02: 8 commits2026-01-03: 14 commits2026-01-04: 26 commits2026-01-05: 7 commits2026-01-06: 12 commits2026-01-07: 1 commit2026-01-08: 5 commits2026-01-09: 3 commits2026-01-10: 20 commits2026-01-11: 41 commits2026-01-12: 10 commits2026-01-13: 15 commits2026-01-14: 15 commits2026-01-15: 3 commits2026-01-16: 1 commit2026-01-17: 0 commits2026-01-18: 8 commits2026-01-19: 22 commits2026-01-20: 18 commits2026-01-21: 17 commits2026-01-22: 14 commits2026-01-23: 22 commits2026-01-24: 20 commits2026-01-25: 44 commits2026-01-26: 17 commits2026-01-27: 2 commits2026-01-28: 16 commits2026-01-29: 10 commits2026-01-30: 12 commits2026-01-31: 28 commits2026-02-01: 32 commits2026-02-02: 19 commits2026-02-03: 10 commits2026-02-04: 8 commits2026-02-05: 20 commits2026-02-06: 20 commits2026-02-07: 13 commits2026-02-08: 25 commits2026-02-09: 15 commits2026-02-10: 16 commits2026-02-11: 8 commits2026-02-12: 6 commits2026-02-13: 7 commits2026-02-14: 28 commits2026-02-15: 30 commits2026-02-16: 24 commits2026-02-17: 11 commits2026-02-18: 5 commits2026-02-19: 8 commits2026-02-20: 6 commits2026-02-21: 25 commits2026-02-22: 33 commits2026-02-23: 26 commits2026-02-24: 10 commits2026-02-25: 9 commits2026-02-26: 14 commits2026-02-27: 7 commits2026-02-28: 29 commits2026-03-01: 26 commits2026-03-02: 16 commits2026-03-03: 7 commits2026-03-04: 5 commits2026-03-05: 13 commits2026-03-06: 30 commits2026-03-07: 7 commits2026-03-08: 27 commits2026-03-09: 37 commits2026-03-10: 20 commits2026-03-11: 14 commits2026-03-12: 2 commits2026-03-13: 3 commits2026-03-14: 22 commits2026-03-15: 39 commits2026-03-16: 1 commit2026-03-17: 12 commits2026-03-18: 18 commits2026-03-19: 17 commits2026-03-20: 42 commits2026-03-21: 21 commits2026-03-22: 13 commits2026-03-23: 21 commits2026-03-24: 6 commits2026-03-25: 41 commits2026-03-26: 27 commits2026-03-27: 17 commits2026-03-28: 57 commits2026-03-29: 17 commits2026-03-30: 26 commits2026-03-31: 6 commits2026-04-01: 9 commits2026-04-02: 11 commits2026-04-03: 9 commits2026-04-04: 20 commits2026-04-05: 11 commits2026-04-06: 5 commits2026-04-07: 1 commit2026-04-08: 1 commit2026-04-09: 5 commits2026-04-10: 1 commit2026-04-11: 1 commit2026-04-12: 9 commits2026-04-13: 11 commits2026-04-14: 11 commits2026-04-15: 4 commits2026-04-16: 19 commits2026-04-17: 8 commits2026-04-18: 14 commits2026-04-19: 18 commits2026-04-20: 8 commits2026-04-21: 17 commits2026-04-22: 11 commits2026-04-23: 11 commits2026-04-24: 20 commits2026-04-25: 36 commits2026-04-26: 28 commits2026-04-27: 19 commits2026-04-28: 11 commits2026-04-29: 10 commits2026-04-30: 3 commits2026-05-01: 23 commits2026-05-02: 14 commits2026-05-03: 2 commits2026-05-04: 1 commit2026-05-05: 0 commits2026-05-06: 2 commits2026-05-07: 2 commits2026-05-08: 9 commits2026-05-09: 64 commits2026-05-10: 38 commits2026-05-11: 11 commits2026-05-12: 10 commits2026-05-13: 4 commits2026-05-14: 15 commits2026-05-15: 4 commits2026-05-16: 10 commits2026-05-17: 22 commits2026-05-18: 28 commits2026-05-19: 10 commits2026-05-20: 8 commits2026-05-21: 6 commits2026-05-22: 9 commits2026-05-23: 29 commits2026-05-24: 36 commits2026-05-25: 41 commits2026-05-26: 15 commits2026-05-27: 13 commits2026-05-28: 4 commits2026-05-29: 1 commit2026-05-30: 0 commits2026-05-31: 0 commits2026-06-01: 0 commits2026-06-02: 15 commits2026-06-03: 11 commits2026-06-04: 17 commits2026-06-05: 5 commits2026-06-06: 11 commits2026-06-07: 13 commits2026-06-08: 4 commits2026-06-09: 3 commits2026-06-10: 6 commits2026-06-11: 24 commits2026-06-12: 4 commits2026-06-13: 37 commits2026-06-14: 39 commits2026-06-15: 16 commits2026-06-16: 13 commits2026-06-17: 5 commits2026-06-18: 6 commits2026-06-19: 11 commits2026-06-20: 23 commits2026-06-21: 51 commits2026-06-22: 8 commits2026-06-23: 8 commits2026-06-24: 10 commits2026-06-25: 21 commits2026-06-26: 4 commits2026-06-27: 35 commits2026-06-28: 27 commits2026-06-29: 8 commits2026-06-30: 2 commits2026-07-01: 8 commits2026-07-02: 22 commits2026-07-03: 6 commits2026-07-04: 15 commits2026-07-05: 1 commit2026-07-06: 9 commits2026-07-07: 8 commits2026-07-08: 6 commits2026-07-09: 6 commits2026-07-10: 4 commits2026-07-11: 27 commits2026-07-12: 3 commits2026-07-13: 11 commits2026-07-14: 7 commits2026-07-15: 10 commits2026-07-16: 12 commits2026-07-17: 8 commits2026-07-18: 5 commits2026-07-19: 13 commits2026-07-20: 13 commits2026-07-21: 1 commit2026-07-22: 2 commits2026-07-23: 1 commit2026-07-24: 7 commits2026-07-25: 19 commits2026-07-26: 5 commits2026-07-27: 9 commits2026-07-28: 1 commit2026-07-29: 9 commits2026-07-30: 6 commits2026-07-31: 7 commits2026-08-01: 8 commits2026-08-02: 11 commits2026-08-03: 12 commits2026-08-04: 6 commits2026-08-05: 11 commits2026-08-06: 18 commits2026-08-07: 22 commits2026-08-08: 20 commits2026-08-09: 7 commits2026-08-10: 12 commits2026-08-11: 1 commit2026-08-12: 0 commits2026-08-13: 8 commits2026-08-14: 17 commits2026-08-15: 11 commits2026-08-16: 10 commits2026-08-17: 7 commits2026-08-18: 0 commits2026-08-19: 0 commits2026-08-20: 3 commits2026-08-21: 6 commits2026-08-22: 3 commits2026-08-23: 3 commits2026-08-24: 6 commits2026-08-25: 7 commits2026-08-26: 8 commits2026-08-27: 11 commits2026-08-28: 15 commits2026-08-29: 2 commits2026-08-30: 0 commits2026-08-31: 5 commits2026-09-01: 0 commits2026-09-02: 4 commits2026-09-03: 21 commits2026-09-04: 17 commits2026-09-05: 10 commits2026-09-06: 17 commits2026-09-07: 9 commits2026-09-08: 7 commits2026-09-09: 4 commits2026-09-10: 2 commits2026-09-11: 0 commits2026-09-12: 28 commits2026-09-13: 17 commits2026-09-14: 5 commits2026-09-15: 11 commits2026-09-16: 13 commits2026-09-17: 33 commits2026-09-18: 18 commits2026-09-19: 22 commits2026-09-20: 11 commits2026-09-21: 4 commits2026-09-22: 3 commits2026-09-23: 0 commits2026-09-24: 1 commit2026-09-25: 32 commits2026-09-26: 29 commits2026-09-27: 30 commits2026-09-28: 1 commit2026-09-29: 4 commits2026-09-30: 1 commit2026-10-01: 11 commits2026-10-02: 27 commits2026-10-03: 19 commits2026-10-04: 24 commits2026-10-05: 9 commits2026-10-06: 16 commits2026-10-07: 1 commit2026-10-08: 0 commits2026-10-09: 3 commits2026-10-10: 43 commits2026-10-11: 90 commits2026-10-12: 8 commits2026-10-13: 1 commit2026-10-14: 13 commits2026-10-15: 39 commits2026-10-16: 8 commits2026-10-17: 40 commits2026-10-18: 26 commits2026-10-19: 22 commits2026-10-20: 0 commits2026-10-21: 0 commits2026-10-22: 8 commits2026-10-23: 29 commits2026-10-24: 63 commits2026-10-25: 5 commits2026-10-26: 6 commits2026-10-27: 14 commits2026-10-28: 17 commits2026-10-29: 32 commits2026-10-30: 12 commits2026-10-31: 9 commits2026-11-01: 4 commits2026-11-02: 7 commits2026-11-03: 9 commits2026-11-04: 18 commits2026-11-05: 2 commits2026-11-06: 1 commit2026-11-07: 15 commits2026-11-08: 45 commits2026-11-09: 9 commits2026-11-10: 8 commits2026-11-11: 1 commit2026-11-12: 11 commits2026-11-13: 10 commits2026-11-14: 35 commits2026-11-15: 8 commits2026-11-16: 13 commits2026-11-17: 13 commits2026-11-18: 0 commits2026-11-19: 0 commits2026-11-20: 0 commits2026-11-21: 0 commits
5,048 commits in the last yearLessMore

Signals and awards

derived from tracked data
  • Very active

    5,048 commits in 52 weeks

  • Community-driven

    ~115 contributors

  • Well documented

    High community health score

  • Permissive license

    MIT

  • Continuous integration

    Automated checks passing

What local-deep-research does

Local Deep Research is a privacy-first research tool that autonomously utilizes local LLMs and search engines to investigate complex topics. Unlike cloud-based alternatives that may expose sensitive data, it executes entirely on local hardware, capable of achieving state-of-the-art results on a single consumer GPU like an RTX 3090 using Qwen3.6-27B. The AI agent iteratively queries search engines such as SearXNG, reads the extracted content, synthesizes findings, and dynamically builds a searchable knowledge base. It ensures all data safely remains on the user's machine while systematically providing highly accurate, comprehensively cited reports.

Academemics, privacy-conscious professionals, and local-LLM enthusiasts who need deep research capabilities without cloud data exposure. Ideal for teams requiring efficient LLMs.

  • Autonomous Deep Search: Conducts iterative deep web research autonomously on complex user queries with extensive synthesis.
  • Local Execution: Runs entirely locally without external API calls, ensuring complete data privacy and data ownership.
  • High Accuracy Architecture: Achieves impressive high accuracy like 95% SimpleQA on standard consumer-grade hardware.
  • SearXNG Integration: Connects directly with SearXNG for optimal, unbiased search result retrieval across multiple engines.
  • Citation Generation: Synthesizes comprehensive final reports featuring strict academic-style source citations for verifiable research.

Where teams use it

Academic Literature Review

Researchers can deploy the agent to systematically search PubMed or arXiv and summarize findings without sharing their hypothesis with cloud providers.

Competitive Analysis

Businesses can use the tool to quietly investigate competitors' public documentation and marketing materials to generate private synthesis reports.

Personal Knowledge Base Generation

Hobbyists can instruct the agent to deep-dive into niche topics and populate a local, searchable database for future reference.

Offline Data Processing

Journalists operating in disconnected or sensitive environments can synthesize massive amounts of cached information securely.

Getting started: docker run -d -p 11434:11434 --name ollama ollama/ollama

README

main branch

Local Deep Research

GitHub stars Docker Pulls PyPI Downloads

Trendshift

Commits Last Commit

SimpleQA Accuracy SQLCipher

OpenSSF Scorecard CodeQL Semgrep

🔧 Pre-commit

🐳 Docker Publish 📦 PyPI Publish

Discord Reddit YouTube

AI-powered research assistant for deep, agentic research

Performs deep, agentic research using multiple LLMs and search engines with proper citations

🧪 First open-source project — fully-local on a single RTX 3090 (Qwen3.6-27B) — to report ~95% SimpleQA (n=500) and 77% xbench-DeepSearch (n=100) on local hardware. See the r/LocalLLaMA announcement and the benchmark dataset.

▶️ Watch Review by The Art Of The Terminal

🚀 What is 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.

⚡ Quick Start

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: Host networking works on Docker Engine for Linux and, for Linux containers, on Docker Desktop 4.34+ when Enable host networking is turned on in Settings → Resources → Network. See Docker's host-network documentation for setup and limitations. For Docker Desktop without that feature enabled, use Option 2 below, or the bridge-network docker run recipe in the Windows/WSL2 FAQ.

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).

🏗️ How It Works

Research

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.

Build Your Knowledge Base

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

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.

🛡️ Security

DevSkim Bearer

OSV-Scanner npm-audit Retire.js

Container Security Dockle Hadolint Checkov

Zizmor OWASP ZAP Security Tests

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

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: Credentials are held in process memory during active sessions. LDR limits their lifetime and applies process dump controls at web and MCP startup on POSIX, with additional dumpability controls on Linux. Other platforms and applications embedding LDR require operating-system configuration. See the Security Policy for scope and platform details.

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 →

🌐 Egress control

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.

Mode Search sources Inference
Adaptive (default) follows your primary engine: a public engine behaves like Public only, a private collection or your library like Private only; a locally stored collection you marked public as primary allows any classified engine, private collections included forced local only when the run is private
Public only public web and academic engines; private collections and local document stores classified as private are excluded (a document store whose URL resolves to a public host, or does not resolve, is normally treated as public) your configured providers; a document-store primary with a cloud model is normally refused at start for research run through the web research form (not for entry points that call the research functions directly, such as /api/v1/quick_summary or MCP)
Private only local sources only (collections, library, local document stores such as Paperless) forced local; cloud providers are normally refused
Strict your single primary engine, no expansion not forced local, but cloud models usually do not work under Strict (see the Strict section of Egress modes)
Unprotected anything; unavailable unless the operator sets LDR_POLICY_ALLOW_UNPROTECTED_EGRESS=true normally anything (an operator's environment lock on the require-local settings still applies)

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 →

🔒 Privacy & Data

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.

📊 Benchmarks

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

Model SimpleQA xbench-DeepSearch
Qwen3.6-27B 95.7% (287/300) 77.0% (77/100)
Qwen3.5-9B 91.2% (182/200) 59.0% (59/100)
gpt-oss-20B 85.4% (295/346) –

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 →.

LangGraph Agent Architecture

%%{init: {"themeVariables": {"fontSize": "14px"}, "flowchart": {"nodeSpacing": 16, "rankSpacing": 20, "padding": 10, "diagramPadding": 0, "curve": "basis"}}}%%
flowchart TB
    accTitle: LangGraph agent architecture
    accDescr: The lead agent calls search, fetch, or parallel subresearch tools. Tool responses return to the lead loop, while successful search and fetch records are collected for citation handling in the final report.
    LA([User Query -> Lead Agent<br/>LLM-driven loop])

    SEARCH[Search<br/>web_search: configured primary source<br/>eligible search_* tools]
    FETCH[Fetch<br/>configured content fetch<br/>fetch response payloads]
    SUB[Subresearch<br/>prefer 2-5 topics<br/>same eligible tools<br/>no recursive research_subtopic]
    OUT[Tool outputs]

    RET[Return to Lead loop<br/>lead tool responses]
    COL[Results Collector<br/>successful Search/Fetch<br/>citation/source records]

    FINAL[Citation Handler<br/>uses collected sources]
    RPT([Final Report<br/>with Sources])

    LA --> SEARCH
    LA --> FETCH
    LA --> SUB
    SEARCH --> OUT
    FETCH --> OUT
    SUB --> OUT
    OUT --> RET
    RET --> LA
    SEARCH -. successful<br/>records .-> COL
    FETCH -. successful<br/>records .-> COL
    SUB -. nested Search/Fetch<br/>records .-> COL
    LA -->|final answer| FINAL
    COL --> FINAL
    FINAL --> RPT

    classDef lead fill:#BFDBFE,stroke:#2563EB,color:#172554,stroke-width:2px
    classDef operation fill:#E2E8F0,stroke:#64748B,color:#0F172A,stroke-width:1.5px
    classDef source fill:#99F6E4,stroke:#0F766E,color:#134E4A,stroke-width:1.5px
    classDef handler fill:#115E59,stroke:#134E4A,color:#FFFFFF,stroke-width:1.5px
    classDef report fill:#1E293B,stroke:#475569,color:#FFFFFF,stroke-width:2px

    class LA lead
    class SEARCH,FETCH,SUB,OUT,RET operation
    class COL source
    class FINAL handler
    class RPT report
    linkStyle default stroke-width:1.5px
Loading

The lead agent uses the configured web_search and fetch_content tools plus specialized search_* tools filtered by egress policy and per-engine agent_enabled. Subagents receive the same eligible tools except research_subtopic; their tool responses feed their own loops, and the combined subresearch response returns to the lead.

Subresearch prefers 2-5 topics per call and accepts up to 10. langgraph_agent.max_subagent_workers (default 4, range 1-32) sets how many subagents run in parallel within a call, never more than the number of subtopics in that call; any remaining subtopics queue until a worker frees up. Successful search and fetch calls also register source records in the shared Results Collector. The Citation Handler uses those records when sources are available for the final report.

✨ Key Features

🔍 Research Modes

  • 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

🛠️ Advanced Capabilities

  • 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)

📰 News & Research Subscriptions

  • 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

🌐 Search Sources

Free Search Engines
  • Academic: arXiv, PubMed, Semantic Scholar
  • General: Wikipedia, SearXNG
  • Technical: GitHub, Elasticsearch
  • Archived pages: Wayback Machine URL fetching
  • News: The Guardian, Wikinews
Premium Search Engines
  • Tavily - AI-powered search
  • Google - Via SerpAPI or Programmable Search Engine
  • Brave Search - Privacy-focused web search
Custom Sources
  • 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.

When the JavaScript-rendering browser checks robots.txt, it applies the rules for the Local-Deep-Research product token as well as the rules that match the User-Agent it sends (Mozilla for the default browser User-Agent, or the first product token of a configured web.user_agent; otherwise *). A page is skipped if either set disallows it, so a site can add restrictions for this app with a User-agent: Local-Deep-Research group; an Allow there does not lift rules from the * group or the group matching the sent User-Agent, unless the configured User-Agent itself matches that Local-Deep-Research group.

Full Search Engines Guide →

💻 Usage Examples

Python API

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"])

HTTP API

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

Command Line Tools

# 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.

🔗 Bring Your Own Knowledge Base

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 →

🔌 MCP Server (Claude Integration)

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.

Installation

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

Claude Desktop Configuration

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-..."
      }
    }
  }
}

Claude Code Configuration

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.

Available Tools

Tool Description Duration LLM Cost
search Raw results from a specific engine (arxiv, pubmed, wikipedia, ...) 5-30s None
quick_research Fast research summary 1-5 min Yes
detailed_research Comprehensive analysis 5-15 min Yes
generate_report Full markdown report 10-30 min Yes
analyze_documents Search local collections 30s-2 min Yes
list_search_engines List available search engines instant None
list_strategies List research strategies instant None
get_configuration Get current config instant None

Individual Search Engines

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

Example Usage

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

🤖 Supported LLMs

Local Models

  • 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.

Cloud Models

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

Custom Endpoints

  • 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 →

🔄 Upgrading from Earlier Versions

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/<user hash>/pre-migration/ to storage outside the data directory immediately after that user's first sign-in on the new release, and in any case before that user's next password change, which can remove it, and before any downgrade attempt. Never start v1.10.7 against the upgraded databases: each sign-in there first makes a backup, keeps only the newest backup directly in the user's backup directory (that new copy of the upgraded database), and then refuses the login. After any rollback to a release before 2.0, move every user's pre-migration/ folder out of the data directory (see the upgrade guide).

  • 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.

📚 Documentation

Getting Started

Core Features

Advanced Features

Development

Examples & Tutorials

📰 Featured In

"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

News & Articles

Community Discussions

International Coverage

🇨🇳 Chinese
🇯🇵 Japanese
🇰🇷 Korean

Reviews & Analysis

Related Projects

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

🤝 Community & Support

    (README truncated)

View on GitHub

Recent activity

commits and pull requests

Releases and announcements

174 total
  1. Release 2.0.1v2.0.1Nov 15, 202628 downloads

    ## Safer credentials and upgrades, background Library downloads, and configurable sampling 2.0.1 is a maintenance release with many security and reliability fixes. A few of them change behavior that existing deployments may depend on, so check the upgrade notes below before upgrading. ### ⚠️ Before you upgrade - **API keys set through environment variables now only go to environment-configured endpoints** (#8265). An API key set through an `LDR_*` variable is sent only to the URL set through the matching `LDR_*` variable, or to the provider's default endpoint. It is no longer sent to a URL saved in account settings. - **What to do:** if you set a key through the environment and a custom endpoint through the Settings UI, also set the endpoint through the environment, for example `LDR_LLM_OPENAI_ENDPOINT_URL`. - **If you don't:** LLM calls, model discovery, embeddings and Paperless will fail or report nothing available. - Settings and Research now show an inline warning when this conflict is detected (#8675). - **`LDR_LLM_REQUIRE_LOCAL_ENDPOINT=enabled` and `LDR_EMBEDDINGS_REQUIRE_LOCAL=enabled` are now enforced.** Previously the egress policy read `enabled` as off, so cloud

  2. Release 2.0.0v2.0.0Nov 7, 202672 downloads

    ## LDR 2.0 **LDR 2.0 is our biggest architectural change yet.** We rebuilt the web layer on FastAPI and Uvicorn, hardened security across the whole app, added new search engines, and made Stop actually stop research mid-generation. It took 1,010 commits in ten weeks, from 40 contributors, 31 of them new to the project. Thank you to everyone who built, tested and reported issues. Several defaults and API contracts changed. **Read the upgrade notes before deploying**, especially if you run LDR behind a reverse proxy or call its HTTP API from your own clients. ### ⚠️ Before you upgrade - **Take a verified offline backup first.** 2.0 changes your databases, and v1.10.7 can't use them afterwards. LDR's built-in backups aren't a substitute (see the next point). Never start v1.10.7 on upgraded data, because doing so can delete your remaining built-in backups. Follow the [upgrade and rollback guide](https://github.com/LearningCircuit/local-deep-research/blob/main/docs/deployment/upgrading.md), which also covers failed upgrades. - **Pre-migration backups now live in their own folder.** Each user gets `encrypted_databases/backups/<user hash>/pre-migration/`. Copy that folder out

  3. Release 1.10.7v1.10.7Aug 28, 2026207 downloads

    ## Security hardening for notification URLs and the news subscription API This is a security release. It closes several server-side request forgery (SSRF) and local-file-read holes in outbound notifications and the news subscription API. If you have notifications enabled or use news subscriptions with a custom LLM endpoint, update promptly. ### Notification URL validation Three related fixes tighten what a notification URL is allowed to do: - **Unsafe Apprise query options are now rejected** before any hostname parsing or DNS lookup (#5085). Options like `template`, `redirect`, and mail-specific SMTP/PGP/WKD parameters could select a second, unvalidated destination or resource — for example, `discord://id/token?template=/etc/passwd` previously made the server read a local file and send it to the webhook. The dependency floor is now `apprise>=1.12.0,<2`, with a test that fails CI if Apprise's query-parsing semantics ever drift from what the validator mirrors. - **The test-notification endpoint now validates every URL in a multi-URL string individually** (#5120, via #5132). Commas are legal URL characters, so previously only the leading entry was checked while Apprise still notif

  4. Release 1.10.6v1.10.6Aug 28, 2026113 downloads

    ## Cross-user isolation fixes and a reworked citation pipeline This release is strongly recommended for multi-user deployments: it closes several ways one signed-in user could touch another user's benchmark runs, research runs, and live progress events. It also contains one small **breaking API change** for external programmatic users of `SearchResultsCollector` — see the first section below. ### Breaking change: `SearchResultsCollector.add_results()` return type If you use LDR's search collector from your own code, `add_results()` now returns `(start, indexed)` instead of just the start index. Migrate `start = collector.add_results(results)` to `start, indexed = collector.add_results(results)` and pass `indexed` to `_format_results()` so deduped `[N]` citation markers stay aligned with the collector. All internal call sites were already updated. (#5381) ### Security: per-user isolation and hardening - **Benchmark runs** were keyed by the per-user integer run id alone, so two users owning the same id (both "run 1") could cancel each other's runs, leak each other's results and credentials, and receive each other's live progress events in the browser. The run registry and Socket

  5. Release 1.10.5v1.10.5Aug 16, 2026182 downloads

    ## Making the SearXNG private-URL guard livable This release smooths out the private-URL protection introduced in v1.10.3, which blocked self-hosted SearXNG instances on localhost/LAN by default but made the failure hard to diagnose and the fix hard to apply. ### If your self-hosted SearXNG stopped returning results The research form now shows a dismissible warning banner when SearXNG is active but its private/localhost instance URL hasn't been approved by the server operator — the situation that previously caused the engine to silently self-disable and return no results. The banner includes the exact environment line needed to fix it. The runtime log message was also upgraded from WARNING to ERROR and now names all three remedies, as does the rejection message when saving such a URL in settings. To approve a self-hosted instance, the server operator picks **one** of these in the server environment, then restarts: - **New in this release (recommended):** `LDR_SEARCH_PRIVATE_ENGINE_URL_ALLOWLIST=http://localhost:8080` — a comma-separated list of exact URL origins that may be private. Finer-grained than the blanket flag: only listed origins get private access. Matching is exact

Code frequency

additions and deletions
+293.8K-293.8KWeek of 2025-11-23: +9,207 linesWeek of 2025-11-23: -5,563 linesWeek of 2025-11-30: +22,265 linesWeek of 2025-11-30: -5,488 linesWeek of 2025-12-07: +33,839 linesWeek of 2025-12-07: -1,577 linesWeek of 2025-12-14: +15,974 linesWeek of 2025-12-14: -1,383 linesWeek of 2025-12-21: +10,107 linesWeek of 2025-12-21: -1,085 linesWeek of 2025-12-28: +10,979 linesWeek of 2025-12-28: -2,533 linesWeek of 2026-01-04: +21,138 linesWeek of 2026-01-04: -3,124 linesWeek of 2026-01-11: +83,062 linesWeek of 2026-01-11: -7,276 linesWeek of 2026-01-18: +72,733 linesWeek of 2026-01-18: -11,420 linesWeek of 2026-01-25: +50,221 linesWeek of 2026-01-25: -4,044 linesWeek of 2026-02-01: +171,421 linesWeek of 2026-02-01: -15,385 linesWeek of 2026-02-08: +23,790 linesWeek of 2026-02-08: -11,509 linesWeek of 2026-02-15: +31,055 linesWeek of 2026-02-15: -6,810 linesWeek of 2026-02-22: +39,854 linesWeek of 2026-02-22: -19,281 linesWeek of 2026-03-01: +57,950 linesWeek of 2026-03-01: -6,681 linesWeek of 2026-03-08: +66,384 linesWeek of 2026-03-08: -9,316 linesWeek of 2026-03-15: +105,853 linesWeek of 2026-03-15: -12,829 linesWeek of 2026-03-22: +47,366 linesWeek of 2026-03-22: -18,242 linesWeek of 2026-03-29: +9,125 linesWeek of 2026-03-29: -6,924 linesWeek of 2026-04-05: +11,118 linesWeek of 2026-04-05: -2,427 linesWeek of 2026-04-12: +16,507 linesWeek of 2026-04-12: -8,996 linesWeek of 2026-04-19: +30,818 linesWeek of 2026-04-19: -20,999 linesWeek of 2026-04-26: +10,132 linesWeek of 2026-04-26: -7,097 linesWeek of 2026-05-03: +11,566 linesWeek of 2026-05-03: -4,450 linesWeek of 2026-05-10: +16,035 linesWeek of 2026-05-10: -4,085 linesWeek of 2026-05-17: +10,408 linesWeek of 2026-05-17: -25,915 linesWeek of 2026-05-24: +35,495 linesWeek of 2026-05-24: -49,071 linesWeek of 2026-05-31: +5,388 linesWeek of 2026-05-31: -44,064 linesWeek of 2026-06-07: +34,072 linesWeek of 2026-06-07: -16,108 linesWeek of 2026-06-14: +17,733 linesWeek of 2026-06-14: -27,018 linesWeek of 2026-06-21: +21,677 linesWeek of 2026-06-21: -16,085 linesWeek of 2026-06-28: +24,492 linesWeek of 2026-06-28: -5,617 linesWeek of 2026-07-05: +12,595 linesWeek of 2026-07-05: -3,134 linesWeek of 2026-07-12: +76,793 linesWeek of 2026-07-12: -2,532 linesWeek of 2026-07-19: +31,569 linesWeek of 2026-07-19: -7,633 linesWeek of 2026-07-26: +12,488 linesWeek of 2026-07-26: -2,085 linesWeek of 2026-08-02: +24,664 linesWeek of 2026-08-02: -3,005 linesWeek of 2026-08-09: +23,725 linesWeek of 2026-08-09: -3,431 linesWeek of 2026-08-16: +6,673 linesWeek of 2026-08-16: -1,582 linesWeek of 2026-08-23: +24,517 linesWeek of 2026-08-23: -4,776 linesWeek of 2026-08-30: +293,767 linesWeek of 2026-08-30: -152,895 linesWeek of 2026-09-06: +65,552 linesWeek of 2026-09-06: -4,952 linesWeek of 2026-09-13: +68,143 linesWeek of 2026-09-13: -6,288 linesWeek of 2026-09-20: +45,717 linesWeek of 2026-09-20: -4,196 linesWeek of 2026-09-27: +56,686 linesWeek of 2026-09-27: -7,441 linesWeek of 2026-10-04: +57,740 linesWeek of 2026-10-04: -4,038 linesWeek of 2026-10-11: +142,130 linesWeek of 2026-10-11: -16,260 linesWeek of 2026-10-18: +91,705 linesWeek of 2026-10-18: -8,527 linesWeek of 2026-10-25: +53,987 linesWeek of 2026-10-25: -11,822 linesWeek of 2026-11-01: +19,211 linesWeek of 2026-11-01: -1,873 linesWeek of 2026-11-08: +71,971 linesWeek of 2026-11-08: -11,251 linesWeek of 2026-11-15: +3,062 linesWeek of 2026-11-15: -2,377 linesNov 23, 2025Nov 15, 2026
+2.3M lines added, -642.5K removed over the last year.

Commits per week

last 52 weeks
1990Week of 2025-11-23: 158 commitsWeek of 2025-11-30: 163 commitsWeek of 2025-12-07: 104 commitsWeek of 2025-12-14: 96 commitsWeek of 2025-12-21: 78 commitsWeek of 2025-12-28: 87 commitsWeek of 2026-01-04: 74 commitsWeek of 2026-01-11: 85 commitsWeek of 2026-01-18: 121 commitsWeek of 2026-01-25: 129 commitsWeek of 2026-02-01: 122 commitsWeek of 2026-02-08: 105 commitsWeek of 2026-02-15: 109 commitsWeek of 2026-02-22: 128 commitsWeek of 2026-03-01: 104 commitsWeek of 2026-03-08: 125 commitsWeek of 2026-03-15: 150 commitsWeek of 2026-03-22: 182 commitsWeek of 2026-03-29: 98 commitsWeek of 2026-04-05: 25 commitsWeek of 2026-04-12: 76 commitsWeek of 2026-04-19: 121 commitsWeek of 2026-04-26: 108 commitsWeek of 2026-05-03: 80 commitsWeek of 2026-05-10: 92 commitsWeek of 2026-05-17: 112 commitsWeek of 2026-05-24: 110 commitsWeek of 2026-05-31: 59 commitsWeek of 2026-06-07: 91 commitsWeek of 2026-06-14: 113 commitsWeek of 2026-06-21: 137 commitsWeek of 2026-06-28: 88 commitsWeek of 2026-07-05: 61 commitsWeek of 2026-07-12: 56 commitsWeek of 2026-07-19: 56 commitsWeek of 2026-07-26: 45 commitsWeek of 2026-08-02: 100 commitsWeek of 2026-08-09: 56 commitsWeek of 2026-08-16: 29 commitsWeek of 2026-08-23: 52 commitsWeek of 2026-08-30: 57 commitsWeek of 2026-09-06: 67 commitsWeek of 2026-09-13: 119 commitsWeek of 2026-09-20: 80 commitsWeek of 2026-09-27: 93 commitsWeek of 2026-10-04: 96 commitsWeek of 2026-10-11: 199 commitsWeek of 2026-10-18: 148 commitsWeek of 2026-10-25: 95 commitsWeek of 2026-11-01: 56 commitsWeek of 2026-11-08: 119 commitsWeek of 2026-11-15: 34 commitsNov 23, 2025Nov 15, 2026
5K commits in the last 52 weeks.

When work happens

weekday and hour
SunMonTueWedThuFriSat036912151821Sun 0:00 — 70 commitsSun 1:00 — 46 commitsSun 2:00 — 51 commitsSun 3:00 — 11 commitsSun 4:00 — 4 commitsSun 5:00 — 6 commitsSun 6:00 — 2 commitsSun 7:00 — 9 commitsSun 8:00 — 62 commitsSun 9:00 — 77 commitsSun 10:00 — 71 commitsSun 11:00 — 87 commitsSun 12:00 — 99 commitsSun 13:00 — 89 commitsSun 14:00 — 79 commitsSun 15:00 — 90 commitsSun 16:00 — 126 commitsSun 17:00 — 94 commitsSun 18:00 — 100 commitsSun 19:00 — 65 commitsSun 20:00 — 76 commitsSun 21:00 — 87 commitsSun 22:00 — 112 commitsSun 23:00 — 104 commitsMon 0:00 — 88 commitsMon 1:00 — 57 commitsMon 2:00 — 21 commitsMon 3:00 — 19 commitsMon 4:00 — 41 commitsMon 5:00 — 6 commitsMon 6:00 — 8 commitsMon 7:00 — 22 commitsMon 8:00 — 44 commitsMon 9:00 — 38 commitsMon 10:00 — 25 commitsMon 11:00 — 17 commitsMon 12:00 — 21 commitsMon 13:00 — 18 commitsMon 14:00 — 15 commitsMon 15:00 — 12 commitsMon 16:00 — 25 commitsMon 17:00 — 34 commitsMon 18:00 — 82 commitsMon 19:00 — 51 commitsMon 20:00 — 88 commitsMon 21:00 — 51 commitsMon 22:00 — 62 commitsMon 23:00 — 80 commitsTue 0:00 — 104 commitsTue 1:00 — 45 commitsTue 2:00 — 17 commitsTue 3:00 — 9 commitsTue 4:00 — 0 commitsTue 5:00 — 5 commitsTue 6:00 — 2 commitsTue 7:00 — 28 commitsTue 8:00 — 18 commitsTue 9:00 — 6 commitsTue 10:00 — 2 commitsTue 11:00 — 9 commitsTue 12:00 — 10 commitsTue 13:00 — 1 commitsTue 14:00 — 18 commitsTue 15:00 — 12 commitsTue 16:00 — 11 commitsTue 17:00 — 14 commitsTue 18:00 — 50 commitsTue 19:00 — 41 commitsTue 20:00 — 77 commitsTue 21:00 — 59 commitsTue 22:00 — 54 commitsTue 23:00 — 85 commitsWed 0:00 — 85 commitsWed 1:00 — 37 commitsWed 2:00 — 12 commitsWed 3:00 — 18 commitsWed 4:00 — 7 commitsWed 5:00 — 7 commitsWed 6:00 — 6 commitsWed 7:00 — 23 commitsWed 8:00 — 20 commitsWed 9:00 — 13 commitsWed 10:00 — 11 commitsWed 11:00 — 17 commitsWed 12:00 — 24 commitsWed 13:00 — 17 commitsWed 14:00 — 8 commitsWed 15:00 — 18 commitsWed 16:00 — 30 commitsWed 17:00 — 24 commitsWed 18:00 — 29 commitsWed 19:00 — 73 commitsWed 20:00 — 73 commitsWed 21:00 — 57 commitsWed 22:00 — 49 commitsWed 23:00 — 89 commitsThu 0:00 — 77 commitsThu 1:00 — 53 commitsThu 2:00 — 27 commitsThu 3:00 — 4 commitsThu 4:00 — 7 commitsThu 5:00 — 5 commitsThu 6:00 — 6 commitsThu 7:00 — 30 commitsThu 8:00 — 40 commitsThu 9:00 — 21 commitsThu 10:00 — 18 commitsThu 11:00 — 17 commitsThu 12:00 — 20 commitsThu 13:00 — 11 commitsThu 14:00 — 14 commitsThu 15:00 — 20 commitsThu 16:00 — 18 commitsThu 17:00 — 37 commitsThu 18:00 — 36 commitsThu 19:00 — 49 commitsThu 20:00 — 62 commitsThu 21:00 — 53 commitsThu 22:00 — 111 commitsThu 23:00 — 108 commitsFri 0:00 — 85 commitsFri 1:00 — 66 commitsFri 2:00 — 31 commitsFri 3:00 — 15 commitsFri 4:00 — 16 commitsFri 5:00 — 10 commitsFri 6:00 — 8 commitsFri 7:00 — 14 commitsFri 8:00 — 31 commitsFri 9:00 — 35 commitsFri 10:00 — 25 commitsFri 11:00 — 34 commitsFri 12:00 — 21 commitsFri 13:00 — 16 commitsFri 14:00 — 20 commitsFri 15:00 — 21 commitsFri 16:00 — 26 commitsFri 17:00 — 50 commitsFri 18:00 — 38 commitsFri 19:00 — 78 commitsFri 20:00 — 63 commitsFri 21:00 — 42 commitsFri 22:00 — 34 commitsFri 23:00 — 80 commitsSat 0:00 — 92 commitsSat 1:00 — 96 commitsSat 2:00 — 41 commitsSat 3:00 — 23 commitsSat 4:00 — 13 commitsSat 5:00 — 5 commitsSat 6:00 — 10 commitsSat 7:00 — 12 commitsSat 8:00 — 44 commitsSat 9:00 — 77 commitsSat 10:00 — 94 commitsSat 11:00 — 99 commitsSat 12:00 — 73 commitsSat 13:00 — 95 commitsSat 14:00 — 107 commitsSat 15:00 — 99 commitsSat 16:00 — 107 commitsSat 17:00 — 57 commitsSat 18:00 — 42 commitsSat 19:00 — 50 commitsSat 20:00 — 41 commitsSat 21:00 — 40 commitsSat 22:00 — 48 commitsSat 23:00 — 56 commits
Commit volume by weekday and hour (UTC). Larger dots mean more commits.

Who is committing

last 52 weeks
Maintainer commits4,574 (77%)
Community commits1,391 (23%)

5,965 commits in total over the last year.

DateListRankStars gained
May 7, 2026daily#25+46