Delv
CommunityActive· 9d4.3by Nikhil Kapila

MCP Local RAG

Local RAG-like web search across 9+ backends with no API keys, running entirely on your machine for fresh web context.

C
Safety & Trust

Delv Safety Grade: C

Score 58/100 · assessed 2026-04-28

Maintainer45
Permissions65
Supply chain40
Transparency75
Incidents100

MCP Local RAG is a community-maintained search server by solo developer Nikhil Kapila that queries nine web search backends without API keys. It runs locally, scrapes web results, and returns chunked context for LLM consumption. The maintainer appears to be an individual contributor with moderate GitHub activity but limited organisational backing, creating bus factor concerns. The install method bypasses standard package registries, using git+https directly through uvx, which reduces supply chain verification. Permissions are moderately scoped: it makes outbound network requests to multiple search engines and scrapes web content, but doesn't touch filesystem writes or shell execution. The repository is open source with reasonable documentation, though the project is relatively young. No security incidents are known. The privacy-focused pitch is genuine, but the solo maintainer and non-standard install path warrant caution for production use.

Lethal Trifecta (prompt-injection exposure)

ONE OF THREE
Private dataYes
Reads secrets, credentials, private files
Untrusted inputNo
Ingests web pages, PRs, issues, emails
External commsNo
Can send data outbound

Local document index.

Green flags

  • No API keys or cloud dependencies required, genuine privacy benefit
  • Open source with visible code and reasonable documentation
  • Read-only search operations, no filesystem or shell access
  • No known security incidents or malicious activity
  • Supports multiple search backends for redundancy

Red flags

  • Solo maintainer with limited organisational backing, bus factor risk
  • Install via git+https bypasses package registry verification
  • Web scraping across 9 backends increases attack surface
  • Young project with limited community review and adoption

Permissions requested

Outbound networkPrivate network
Assessed by Delv Editorial using public metadata. Grades are advisory and update as the ecosystem changes. They do not replace your own review of permissions and code before granting an agent access to sensitive systems.

Install

uvx --python=3.10 --from git+https://github.com/nkapila6/mcp-local-rag mcp-local-rag

Review

MCP Local RAG is a search server that queries the web through nine different backends—DuckDuckGo, Brave, Searx, Tavily, and others—without needing API keys or cloud dependencies. It runs entirely on your machine, scrapes results, chunks them, and hands back context you can feed into Claude or another LLM. The pitch is simple: fresh web data for research, summarisation, or fact-checking, all offline-friendly and free. I'd reach for this when I'm prototyping something that needs current information but I don't want to burn API credits or leak queries to a third party. It's particularly useful for one-off research tasks—say, comparing product specs, pulling recent news on a niche topic, or checking if a library's documentation has changed. The multi-engine fallback is clever: if DuckDuckGo rate-limits you, it tries Brave, then Searx, and so on. That redundancy matters when you're querying aggressively. The quirks are real. This isn't a polished product. You're running web scrapers locally, which means you inherit all the fragility of HTML parsing. Some backends will time out. Some will return garbage. The chunking logic is basic—don't expect semantic splitting or anything clever. It's also Python 3.10-only, which is fine if you're already in that ecosystem but annoying if you're not. The repo is light on documentation, so you'll need to read the code to understand what each backend actually does. Who shouldn't bother: anyone expecting production-grade reliability or semantic search. This is a developer tool for people who understand the trade-offs of scraping and are comfortable debugging when a backend misbehaves. If you need guaranteed uptime or structured data, pay for a proper search API. But if you're building a prototype, doing ad-hoc research, or just want to avoid vendor lock-in, this is a solid starting point. It does one thing—fetch and chunk web results—and does it without asking for your credit card.
Verdict

Install this if you need fresh web context for Claude without API costs or privacy leaks, and you're comfortable with the brittleness of web scraping. Skip it if you need production reliability or semantic search—this is a pragmatic developer tool, not a polished product.

Good at

  • No API keys or cloud dependencies—runs entirely on your machine with no recurring costs.
  • Nine different search backends with automatic fallback, so if one fails you still get results.
  • Genuinely private—queries never leave your network, which matters for sensitive research.
  • Straightforward install via uvx and works out of the box with Claude Desktop.

Watch out

  • Web scraping is inherently fragile—backends time out, HTML changes, and results can be inconsistent.
  • Chunking logic is basic, so you won't get semantic splitting or intelligent context windowing.
  • Python 3.10-only requirement is restrictive if you're on a different version.
  • Light documentation means you'll need to read the source to understand backend behaviour.
  • Not suitable for production use—this is a prototype tool, not a reliable service.

Use cases

  • offline-friendly web search
  • private RAG
  • multi-engine fallback
  • cost-free research

Getting started

1. Install via uvx with Python 3.10: `uvx --python=3.10 --from git+https://github.com/nkapila6/mcp-local-rag mcp-local-rag`. This pulls the server directly from the repo. 2. Add it to your Claude Desktop config under `mcpServers` with the command pointing to the installed binary. No environment variables needed. 3. Restart Claude Desktop and check the MCP tools panel—you should see search functions for each backend listed. 4. Test with a simple query like 'search DuckDuckGo for recent Python releases' to verify it returns chunked results. 5. Watch out for rate limits and timeouts—some backends are flaky, so don't rely on a single engine for critical workflows.

Works with

Claude DesktopClaude CodeCursor

Similar MCPs