Skip to content

Search Gateways Compared: Hound (master-fetch) vs SearXNG vs ddgs

A research article on the three open-source ways to get multi-engine web search without paying a search API: a local MCP server (Hound), a self-hosted metasearch service (SearXNG), and a search library (ddgs). Research date: Aug 2, 2026. All facts verified by direct fetch (GitHub API, raw READMEs, official docs). Companion articles: web-search-ecosystem.md (provider ecosystem, rate limits, free quotas), same-model-different-cli.md, agent-loop-pattern.md.

TL;DR

If you want multi-engine web search in an agent CLI, the ecosystem has three open-source options, and they are not competitors — they are layers:

  1. Hound (dondai1234/master-fetch, 760★, MIT) — a local MCP server with 6 tools (search/fetch/crawl/screenshot). It vendors ddgs as its keyless search backbone (NOTICE.ddgs.txt), adds a stealth browser, circuit breakers, consensus ranking, and a BYOK API layer. The only one that speaks MCP natively.
  2. SearXNG (34.8k★, AGPL-3.0) — a self-hosted metasearch web service aggregating up to 274 search services, with a web UI and JSON API. Its privacy model: the server's IP takes the heat, so your IP never touches engines.
  3. ddgs (2.9k★, MIT) — a Python library that aggregates diverse search services. The building block, not a product.

The honest lineage, in Hound's own words: "Same gray-area posture as SearXNG / ddgs; no search-engine ToS compliance is claimed" (https://github.com/dondai1234/master-fetch/blob/master/README.md).

Recommendation for agent-CLI research (protect IP + BYOK ok + one framework + max free quota): Hound with all five BYOK providers configured (≈48.5k free searches/month via official APIs, IP never scraped). Add SearXNG only if you want a server-side, keyless IP shield. ddgs is already inside Hound — never install it separately.

Part 1 — The three candidates

1.1 Hound (a.k.a. master-fetch, hound-mcp on PyPI)

  • Repo: https://github.com/dondai1234/master-fetch — 760★, MIT, Python, created 2026-06-01, active (pushed 2026-07-24).
  • Self-description (GitHub API): "MCP server for web fetching with Cloudflare bypass, Trafilatura extraction, and smart routing. Free, self-hosted, no API keys."
  • One MCP server, 6 tools: smart_fetch (HTTP-first, auto-escalates to anti-detect browser; bulk, PDF+OCR, css_selector, focus), smart_crawl (best-first same-domain), smart_search (keyless multi-engine), screenshot, cache_clear, version — hand-crafted tool defs ≈2.9K tokens.
  • Search backbone: vendored ddgs (src/master_fetch/search_metasearch.py, MIT, attributed in https://github.com/dondai1234/master-fetch/blob/master/NOTICE.ddgs.txt), "stripped to text search only, and adapted (async-native parallel aggregation with early-return-on-quorum)".
  • 10 keyless backends: duckduckgo, brave, mojeek, yahoo, yandex, startpage, google, qwant (+ opt-in wikipedia, grokipedia) — mapped to index families so consensus is counted across independent indexes (DDG+Yahoo = 1 family, DDG+Brave = 2): https://github.com/dondai1234/master-fetch/blob/master/src/master_fetch/search_engines.py
  • Ranking: six-signal composite (neural ONNX cross-encoder ms-marco-MiniLM-L-6-v2, cross-family consensus, domain reputation, answer-signal scoring, title/URL relevance, diversity max-2-per-domain): https://github.com/dondai1234/master-fetch/blob/master/src/master_fetch/search.py
  • Resilience layer (README): persistent warm sessions, per-engine jittered pacing, circuit breaker + 60s cooldown, DDG 202-soft-limit detection + Retry-After honoring, TLS fingerprint rotation (primp), diversity quorum (≥3 backends), HOUND_SEARCH_PROXY rotation pool (≤20 proxies).
  • BYOK: hound keys add for Serper / Tavily / Exa / Firecrawl / TinyFish. Keys become primary; keyless engines shut off; KeyPool round-robin with 429 → 60s cooldown → next key → keyless as last resort (https://github.com/dondai1234/master-fetch/blob/master/src/master_fetch/search_api_keys.py). One provider per search, sequential exhaustion.
  • Intent-aware fan-out: query intent detection (comparison/howto/research/code/reference/news/factual) → expanded query variant + specialized free JSON-API backends (Semantic Scholar, GitHub API @10 req/min unauth, Hacker News): https://github.com/dondai1234/master-fetch/blob/master/src/master_fetch/api_backends.py
  • Deployment: pip install hound-mcp[all] && playwright install chromium; Docker HTTP mode on :8765/mcp; graceful HTTP-only degradation without browser deps.

1.2 SearXNG

  • Repo: https://github.com/searxng/searxng — 34.8k★, AGPL-3.0, fork of searx (2021).
  • Official docs (https://docs.searxng.org/): "SearXNG is a free internet metasearch engine which aggregates results from up to 274 search services. Users are neither tracked nor profiled. Additionally, SearXNG can be used over Tor."
  • Engine breadth includes API-backed engines, not just scraping: Brave, Exa API, arXiv, Semantic Scholar, GitHub Code, Wikimedia, PubMed, Qwant, Google, Bing, DuckDuckGo, Startpage, Yahoo, Kagi… (engine list: https://docs.searxng.org/dev/engines/engine_overview.html).
  • Interfaces: web UI (JS/cookies optional), JSON API (https://docs.searxng.org/dev/search_api.html), ~70 public instances at https://searx.space.
  • Privacy model: the server's IP does the scraping — that is the whole point of a private instance ("Why use a private instance?" https://docs.searxng.org/own-instance.html). Includes a limiter (https://docs.searxng.org/admin/searx.limiter.html) and an admin flow to "Answer CAPTCHA from server's IP" (https://docs.searxng.org/admin/answer-captcha.html).
  • No native MCP server, no fetch/crawl tools, no neural reranking.

1.3 ddgs

  • Repo: https://github.com/deedy5/ddgs — 2.9k★, MIT, Python.
  • GitHub API description: "A metasearch library that aggregates results from diverse web search services."
  • Per Hound's NOTICE: it is the metasearch engine layer (scraping + parsing + rotation) that Hound vendored; runtime deps primp/httpx/fake-useragent/lxml.
  • Library-level API only: you write the app/MCP layer, ranking, and resilience yourself.

1.4 Also in this space (smaller, unproven)

  • busigui2023/mcp-server-metasearch — local MCP aggregating 15 tools across 5 API providers (Jina, Tavily, Exa, Firecrawl, Bocha), ~0★.
  • positive666/Deep_search_lightning — multi-engine aggregated search + reflection loop with an MCP server, ~0★.

Part 2 — Head-to-head (verified Aug 2, 2026)

Dimension Hound (master-fetch) SearXNG ddgs
What it is Local MCP server for agents Self-hosted metasearch web service (UI + JSON API) Python library
Stars / license 760★ / MIT 34.8k★ / AGPL-3.0 2.9k★ / MIT
Engines 10 keyless + 3 specialized free APIs (Semantic Scholar, GitHub, HN) up to 274 services (web, image, video, news, code, papers…) incl. API engines "diverse web search services" (scraping)
Relationship vendors ddgs (NOTICE.ddgs.txt) independent lineage (searx fork, 2021) building block used by Hound
BYOK / official-API mode Yes — Serper, Tavily, Exa, Firecrawl, TinyFish; key stacking, 429 rotation, keyless fallback Yes — per-engine API keys in settings.yml (e.g., Brave, Exa API) No
Where the scraping heat lands your IP (keyless mode); nobody (BYOK mode) the server's IP — your IP never touches engines your IP (you handle proxies)
Agent integration Native MCP (6 tools), works with Claude Code / OpenCode / Cursor / Pi JSON API only — needs a wrapper for MCP none — build it
Fetch / crawl / anti-bot Yes — smart_fetch with patchright stealth browser, CF Turnstile solver, PDF+OCR, sitemap crawl No fetch layer; CAPTCHA answered server-side No
Ranking Six-signal: neural rerank + cross-family consensus + domain/answer signals Engine merging with per-engine weights; no neural rerank Raw merged results
Rate-limit resilience Built-in: circuit breakers, 60s cooldowns, Retry-After, quorum, warm sessions, proxy rotation Server-side limiter, engine timeouts, ~70 maintained public instances absorb the heat DIY
Multi-user Single local user Yes (web UI, limiter, Tor support) N/A
Setup cost 2 commands + MCP config Docker + settings.yml (or use a public instance) pip + code
Best for Single-user agent-CLI research Privacy-first multi-user search / shared search backend / Tor Embedding metasearch in custom code

3.1 The three are layers, not rivals

ddgs  ──vendored──▶  Hound ──MCP──▶  your agent CLI
                          ▲
                    BYOK: Tavily/Exa/Serper/Firecrawl/TinyFish (official APIs)
SearXNG ──JSON API──▶  your agent (or Hound's keyless engines via proxy) — server-side IP shield

3.2 Decision ladder for the "protect IP + BYOK ok + one framework + max free quota" constraints

Step Choice Why (verified)
1. Default Hound + BYOK, all five providers Single MCP framework; keys = official APIs (IP never scraped); providers consumed sequentially, ≈2,500+1,000+1,000+1,000+43,000 ≈ 48.5k free searches/month; keyless engines only as last-resort fallback
2. If a provider quota dies hound keys test/status, or stack a second key for that provider KeyPool round-robins with 429 → 60s cooldown; capacity scales per provider
3. If strict "never scrape from my IP" Remove/hold keys at exhaustion instead of letting keyless fallback fire The fallback is the only path that touches your IP (README)
4. If you want keyless + IP-protected Host SearXNG on a VPS; point your agent at its JSON API Server IP takes the heat; ~70 public instances also exist — but this adds infra for a single user
5. Never ddgs directly It's already inside Hound (vendored, MIT-attributed)

3.3 Where this sits in the ecosystem article

This is the "self-hosted gateway" tier below the API tier from web-search-ecosystem.md: Hound reproduces the rate-limit playbook from Part 2 of that article (Retry-After honoring, exponential backoff via cooldowns, batching via parallel fan-out, caching via SQLite) and the free-quota dials from Part 3 (per-provider free tiers as BYOK sources, structured free APIs as specialized backends). The one thing no keyless tool can escape — per-IP throttling — is handled either by HOUND_SEARCH_PROXY rotation or by BYOK keys, which is why the recommended stack leads with BYOK.

Conclusion

Hound, SearXNG, and ddgs solve the same problem at three different altitudes: ddgs is the engine layer (already vendored inside Hound), SearXNG is the server-side IP shield with unmatched engine breadth (274 services), and Hound is the only MCP-native, agent-ready gateway with ranking, fetch/crawl/anti-bot, and a BYOK path that turns free API tiers into 48.5k protected searches/month. For a single-user agent CLI, the recommended approach is Hound + BYOK-all-five, with SearXNG as an optional upgrade only if keyless, IP-shielded search is required.

References (all verified Aug 2, 2026)

Hound (master-fetch) - Repo (meta, 760★, MIT): https://github.com/dondai1234/master-fetch · README: https://raw.githubusercontent.com/dondai1234/master-fetch/master/README.md - Vendored ddgs attribution: https://github.com/dondai1234/master-fetch/blob/master/NOTICE.ddgs.txt - Engine layer / index families: https://github.com/dondai1234/master-fetch/blob/master/src/master_fetch/search_engines.py - Six-signal ranking + intent fan-out: https://github.com/dondai1234/master-fetch/blob/master/src/master_fetch/search.py - BYOK key pooling: https://github.com/dondai1234/master-fetch/blob/master/src/master_fetch/search_api_keys.py - Specialized free-API backends: https://github.com/dondai1234/master-fetch/blob/master/src/master_fetch/api_backends.py - MCP server / tools / instructions: https://github.com/dondai1234/master-fetch/blob/master/src/master_fetch/server.py

SearXNG - Repo (34.8k★, AGPL-3.0): https://github.com/searxng/searxng - Docs (274 engines, Tor, instances): https://docs.searxng.org/ - JSON API: https://docs.searxng.org/dev/search_api.html · limiter: https://docs.searxng.org/admin/searx.limiter.html · server-IP CAPTCHA: https://docs.searxng.org/admin/answer-captcha.html - Public instances: https://searx.space

ddgs - Repo (2.9k★, MIT): https://github.com/deedy5/ddgs

Related (small, unproven) - mcp-server-metasearch (5 providers, 15 tools): https://github.com/busigui2023/mcp-server-metasearch - Deep_search_lightning (multi-engine + reflection): https://github.com/positive666/Deep_search_lightning