Local Deep Research: 95% SimpleQA on a Single GPU — Why Developers Are Ditching Cloud AI for This Open-Source Beast

Your research queries are being harvested. Every question you feed ChatGPT, every deep-dive prompt you send to Claude — logged, analyzed, potentially leaked. For developers, researchers, and organizations handling sensitive intellectual property, this isn't paranoia. It's a career-ending liability waiting to happen. But what if you could match — even surpass — the research capabilities of cloud AI giants while keeping every byte of data locked inside your own hardware?

Enter Local Deep Research, the open-source project that's shattering assumptions about what local LLMs can achieve. We're talking ~95% accuracy on SimpleQA benchmarks using Qwen3.6-27B running on a single consumer RTX 3090. No API keys. No subscription fees. No data exfiltration. Just pure, agentic research power that rivals — and in privacy terms, obliterates — its cloud competitors.

The local LLM revolution isn't coming. It's already here, and LearningCircuit/local-deep-research is leading the charge with military-grade encryption, 20+ research strategies, and a knowledge base that compounds with every search. Ready to reclaim your research autonomy? Let's dive deep.

What Is Local Deep Research?

Local Deep Research (LDR) is an AI-powered research assistant designed for deep, agentic investigation — built from the ground up for users who refuse to compromise on privacy. Created by the LearningCircuit team, this open-source project has rapidly become one of the most starred repositories in the local AI ecosystem, earning recognition from LangChain's official channels and coverage across international tech media.

At its core, LDR performs what its creators call "deep, agentic research": autonomous investigation cycles where the AI decides what to search, which specialized engines to query, and when to synthesize findings into cited reports. Unlike simple RAG (Retrieval-Augmented Generation) systems, LDR operates as a true research agent — planning, executing, and refining its approach based on intermediate findings.

The project's headline achievement — ~95% SimpleQA accuracy with Qwen3.6-27B on a single RTX 3090 — represents a watershed moment for local AI. SimpleQA is a demanding benchmark testing factual accuracy across diverse domains. Prior to LDR, such performance was assumed to require cloud-scale infrastructure or proprietary models. The fact that a fully local setup can now compete at this level has sent ripples through the r/LocalLLaMA community (161K+ views on the announcement post) and attracted attention from academic reviewers studying deep research tools.

LDR supports all major local and cloud LLM providers: Ollama, LM Studio, llama.cpp, OpenAI, Anthropic, Google Gemini, and 100+ models via OpenRouter. Its search infrastructure spans 10+ engines including arXiv, PubMed, Semantic Scholar, Wikipedia, SearXNG, and even your private documents. Everything is encrypted with SQLCipher using AES-256 — Signal-level security — with per-user isolated databases and zero telemetry.

Key Features That Separate LDR from the Pack

🔍 Multi-Modal Research Strategies

LDR doesn't force a one-size-fits-all approach. Choose from 20+ research strategies tuned for different needs:

• Quick Summary: Answers in 30 seconds to 3 minutes with citations — perfect for rapid fact-checking
• Detailed Research: Comprehensive analysis with structured findings for complex topics
• Report Generation: Professional reports with sections, table of contents, and full bibliography
• LangGraph Agent Strategy: The crown jewel — an autonomous agentic mode where the LLM dynamically selects search engines, adapts based on findings, and collects significantly more sources than pipeline approaches. This is the strategy behind that ~95% SimpleQA result.

🛡️ Security Architecture That Shames Enterprise Software

LDR's security posture is obsessive — and that's a compliment. Every user gets their own SQLCipher-encrypted database with AES-256 encryption. No password recovery means true zero-knowledge architecture: even server administrators cannot read your data. The project runs 15+ automated security scanners including CodeQL, Semgrep, OSV-Scanner, OWASP ZAP, and container security tools. Docker images are signed with Cosign and include SLSA provenance attestations.

Critical privacy commitment: Zero telemetry, zero analytics, zero tracking. No analytics SDKs, no phone-home calls, no crash reporting. The only network calls are ones you initiate: your configured search engines and your chosen LLM provider.

📚 Compounding Knowledge Base

Here's where LDR gets truly clever. Every research session surfaces valuable sources — academic papers, web pages, articles. Download them directly into your encrypted library. LDR extracts text, indexes everything, and makes it searchable. Next time you research, you query across your accumulated documents AND the live web simultaneously. Your knowledge compounds. Your research accelerates.

🔌 Enterprise-Ready Integrations

• LangChain Retrievers: Plug in FAISS, Chroma, Pinecone, Weaviate, Elasticsearch, or any custom retriever
• REST API: Authenticated HTTP access with per-user database isolation
• MCP Server: Native integration with Claude Desktop and Claude Code via Model Context Protocol
• Analytics Dashboard: Track costs, performance, and usage metrics locally

Real-World Use Cases Where LDR Dominates

1. Academic & Scientific Research

Imagine you're a PhD candidate investigating CRISPR clinical trials. LDR's LangGraph Agent automatically routes queries to PubMed for biomedical literature, arXiv for preprint methodologies, and Semantic Scholar for citation networks. The journal quality system — powered by OpenAlex, DOAJ, and Stop Predatory Journals — flags predatory publishers and scores source reputation using 212K+ indexed sources. You get a synthesized report with proper citations, not a hallucinated summary.

2. Competitive Intelligence in Regulated Industries

Financial services, healthcare, legal — industries where sending proprietary queries to cloud AI is compliance suicide. LDR runs fully local: Ollama + SearXNG, nothing leaves your machine. Research competitor patent filings, regulatory changes, or market trends with complete air-gapped security. The per-user encrypted databases mean even in multi-user deployments, data isolation is cryptographically guaranteed.

3. Software Architecture & Technical Due Diligence

Evaluating a new framework? LDR searches GitHub repositories, Stack Exchange discussions, technical documentation, and your organization's existing codebase simultaneously. The adaptive rate limiting learns optimal retry patterns, preventing search engine blocks during intensive research sessions. Export findings as PDF or Markdown for stakeholder presentations.

4. Automated Research Monitoring

Subscribe to topics and receive AI-powered research digests on customizable schedules. Track emerging vulnerabilities, new ML architectures, or regulatory developments. The WebSocket support delivers real-time progress updates, and the smart filtering ensures you only see genuinely relevant developments — not noise.

Step-by-Step Installation & Setup Guide

Option 1: Docker Run (Linux — Fastest Path)

# Step 1: Pull and run Ollama for local LLM inference
docker run -d -p 11434:11434 --name ollama ollama/ollama
docker exec ollama ollama pull gpt-oss:20b  # Pull a capable research model

# Step 2: Pull and run SearXNG for privacy-respecting search aggregation
docker run -d -p 8080:8080 --name searxng searxng/searxng

# Step 3: Pull and run Local Deep Research with persistent encrypted storage
docker run -d -p 5000:5000 --network host \
  --name local-deep-research \
  --volume "deep-research:/data" \
  -e LDR_DATA_DIR=/data \
  localdeepresearch/local-deep-research

Critical Note for Mac/Windows/WSL2 Users: --network host only works on native Linux. On Docker Desktop, this silently fails to publish port 5000 AND breaks localhost resolution. Use Option 2 (Docker Compose) below, or consult the Windows/WSL2 FAQ.

Option 2: Docker Compose (Recommended for All Platforms)

CPU-only (works everywhere):

# Download the compose file and spin up the full stack
curl -O https://raw.githubusercontent.com/LearningCircuit/local-deep-research/main/docker-compose.yml && docker compose up -d

With NVIDIA GPU acceleration (Linux only):

# Fetch both base and GPU override configurations
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 approximately 30 seconds. The GPU override enables CUDA acceleration for embedding generation and LLM inference, dramatically speeding up research cycles.

Option 3: pip Install (Maximum Flexibility)

# Install from PyPI with pre-built SQLCipher wheels — no compilation needed
pip install local-deep-research

# Launch the web UI
python -m local_deep_research.web.app   # Serves on http://localhost:5000

Prerequisites for pip install:

• Ollama (or any OpenAI-compatible LLM endpoint) running
• SearXNG instance for web search aggregation
• Windows users: Pango library for PDF export (setup guide)

Troubleshooting encryption issues:

# Fallback to standard SQLite if SQLCipher encounters platform issues
export LDR_BOOTSTRAP_ALLOW_UNENCRYPTED=true

REAL Code Examples from the Repository

Example 1: Python API — One-Line Research

from local_deep_research.api import LDRClient, quick_query

# Option 1: Dead simplest — research in a single function call
# Authenticates, executes research, and returns summarized findings
summary = quick_query("username", "password", "What is quantum computing?")
print(summary)

# Option 2: Client for multiple operations — better for application integration
client = LDRClient()
client.login("username", "password")  # Establishes session with encrypted DB

# quick_research uses the default strategy (configurable in Settings)
result = client.quick_research("What are the latest advances in quantum computing?")
print(result["summary"])  # Structured response with citations and source metadata

What's happening here? The quick_query convenience function handles authentication, research execution, and result formatting in one shot. For integration scenarios, the LDRClient class maintains session state, enabling multiple operations without re-authenticating. The returned dictionary includes the summary, source URLs, confidence scores, and full citation data — everything needed for programmatic consumption or UI rendering.

Example 2: HTTP API with CSRF Protection

import requests
from bs4 import BeautifulSoup

# Create persistent session for cookie management
session = requests.Session()

# Step 1: Fetch login page to extract CSRF token
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")

# Step 2: Authenticate with credentials and CSRF token
session.post("http://localhost:5000/auth/login",
            data={
                "username": "user",
                "password": "pass",
                "csrf_token": login_csrf
            })

# Step 3: Obtain API-specific CSRF token for subsequent requests
csrf = session.get("http://localhost:5000/auth/csrf-token").json()["csrf_token"]

# Step 4: Initiate research with proper authentication headers
response = session.post(
    "http://localhost:5000/api/start_research",
    json={"query": "Your research question"},
    headers={"X-CSRF-Token": csrf}  # Required for state-changing operations
)

# Poll for completion or use WebSocket for real-time updates
research_id = response.json()["research_id"]

Security insight: LDR implements double-submit cookie pattern with CSRF tokens for all state-changing operations. The login flow requires extracting a token from the HTML form, then obtaining a separate API token for programmatic access. This prevents cross-site request forgery attacks even if session cookies are compromised. The repository provides complete working examples with automatic user creation, retry logic, and progress monitoring.

Example 3: Enterprise LangChain Integration

from local_deep_research.api import quick_summary

# Integrate with your existing vector store infrastructure
result = quick_summary(
    query="What are our deployment procedures?",
    retrievers={
        "company_kb": your_retriever  # Any LangChain-compatible retriever
    },
    search_tool="company_kb"  # Route search to internal knowledge base
)

# The retriever can be FAISS, Chroma, Pinecone, Weaviate, Elasticsearch,
# or any custom implementation conforming to LangChain's BaseRetriever interface

Architecture note: This pattern enables hybrid research — combining internal proprietary documents with external web search. The retrievers dictionary maps logical names to retriever instances, and search_tool specifies which source to prioritize. For multi-source research, omit search_tool and LDR will intelligently route queries based on content type detection.

Example 4: MCP Server Configuration for Claude Desktop

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

Integration context: The Model Context Protocol (MCP) enables Claude Desktop to invoke LDR's research capabilities as native tools. The ldr-mcp command starts a stdio-based server that Claude communicates with directly. Available tools include search (raw engine results, no LLM cost), quick_research (1-5 minutes), detailed_research (5-15 minutes), and generate_report (10-30 minutes). Critical security warning: This MCP server is designed for local use only — no built-in authentication or rate limiting. Never expose over a network without additional security controls.

Example 5: Command-Line Benchmarking

# Evaluate your configuration against standard datasets
python -m local_deep_research.benchmarks --dataset simpleqa --examples 50

# Monitor and manage adaptive rate limiting state
python -m local_deep_research.web_search_engines.rate_limiting status
python -m local_deep_research.web_search_engines.rate_limiting reset

Optimization insight: The benchmarking module enables empirical configuration tuning — test which model/search/strategy combination maximizes accuracy for your use case. The rate limiting CLI exposes LDR's intelligent retry system, which learns optimal wait times per search engine to prevent blocks while minimizing latency.

Advanced Usage & Best Practices

Model Selection Strategy

Don't guess — benchmark first. The LDR Benchmarks dataset on Hugging Face provides community-submitted accuracy numbers across configurations. For local deployment, Qwen3.6-27B currently leads on SimpleQA (95.7%), but gpt-oss-20B offers a compelling accuracy/size tradeoff at 85.4%. Smaller models like Qwen3.5-9B still achieve 91.2% — viable for resource-constrained environments.

Search Engine Optimization

Configure SearXNG as your meta-search backend for optimal privacy and coverage. It aggregates results from multiple engines without direct API dependencies. For academic research, enable arXiv + PubMed + Semantic Scholar in the LangGraph Agent strategy — the agent will automatically select based on query content.

Knowledge Base Hygiene

Regularly curate your downloaded sources. The encrypted library supports full-text search, but quality degrades with noise. Use the journal quality filter to auto-exclude predatory publications. Export completed research as PDF for archival, then prune working documents to maintain search performance.

Security Hardening

• Verify Docker image signatures: cosign verify localdeepresearch/local-deep-research:latest
• Rotate encryption passwords periodically (no recovery possible — store in password manager)
• Enable LDR_BOOTSTRAP_ALLOW_UNENCRYPTED=false in production to enforce encryption
• Review security scanner results before major deployments

Comparison with Alternatives

Verdict: Choose LDR when privacy, cost control, model flexibility, or offline operation are non-negotiable. Cloud alternatives offer convenience but require trust in opaque infrastructure. For organizations handling sensitive data, LDR isn't just preferable — it's often the only compliant option.

Frequently Asked Questions

Can Local Deep Research really match cloud AI accuracy?

Yes — with the right configuration. The ~95% SimpleQA result with Qwen3.6-27B demonstrates parity with leading cloud systems on factual question-answering. The LangGraph Agent's adaptive multi-engine search compensates for any individual model limitations by retrieving more sources and verifying across engines.

What hardware do I actually need?

Minimum: CPU-only operation works for lighter research (Docker Compose CPU profile). Recommended: NVIDIA GPU with 24GB+ VRAM for 27B parameter models at acceptable speed. The RTX 3090/4090 are proven targets. Smaller models (9B parameters) run comfortably on 16GB VRAM or even CPU with patience.

Is my data truly secure? What if I forget my password?

AES-256 encryption with SQLCipher, per-user isolated databases, zero telemetry. There is no password recovery — this is intentional zero-knowledge architecture. Store your password in a password manager. Server administrators cannot decrypt your data. Period.

How does this differ from running Ollama with a web UI?

Ollama provides the LLM engine; LDR provides the research agent layer. LDR adds autonomous search planning, multi-engine coordination, source verification, citation generation, knowledge base accumulation, and encrypted persistence. It's the difference between having an engine and having a complete research vehicle.

Can I use cloud LLMs with LDR for better quality?

Absolutely. LDR supports OpenAI, Anthropic, Google, and 100+ models via OpenRouter. Many users run hybrid configurations: local for sensitive queries, cloud for maximum capability. Your choice per research session.

What about PDF export on Windows?

Install Pango following the WeasyPrint setup guide. This is a one-time dependency for document generation. Alternatively, use Markdown export which has no additional requirements.

How do I contribute benchmarks or improvements?

Submit benchmark results to the ldr-benchmarks repository. For code contributions, keep PRs small and atomic — one change per request. Open an issue first for substantial features to align with maintainers and protect your development time.

Conclusion: Your Research, Your Rules

Local Deep Research represents something rare in today's AI landscape: genuine capability without compromise. You don't trade accuracy for privacy. You don't sacrifice flexibility for convenience. You don't accept black-box operations to get sophisticated features.

The benchmarks don't lie. ~95% SimpleQA on local hardware isn't a theoretical claim — it's a reproducible result with community-verified methodology. The security posture isn't marketing fluff — it's 15+ automated scanners, cryptographic signatures, and transparent vulnerability management. The ecosystem isn't vaporware — it's active development with Discord support, Reddit community, and international contributor networks.

For developers building AI-powered applications, researchers handling sensitive topics, organizations requiring compliance, or simply individuals who believe their intellectual curiosity shouldn't be monetized by surveillance capitalism — LDR delivers.

The installation takes five minutes. The privacy lasts forever.

👉 Star the repository, join the Discord community, and start your first fully private research session today: github.com/LearningCircuit/local-deep-research

The future of AI research is local, encrypted, and under your control. Don't let anyone tell you otherwise.