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). Original research date: Aug 2, 2026. Revised: Sep 5, 2026, after a follow-up audit of Hound/master-fetch. Facts were verified by direct fetch (GitHub API, raw READMEs, official docs, PyPI metadata). Companion articles: web-search-ecosystem.md (provider ecosystem, rate limits, free quotas), same-model-different-cli.md, agent-loop-pattern.md.

⚠️ Sep 5, 2026 audit update — Hound (master-fetch) is no longer the default recommendation

A re-check of the actual repositories and PyPI metadata changed the Aug 2 verdict. The originally profiled repo (dondai1234/master-fetch) has had no code push since 2026-07-24 and is frozen at v12.4.1. PyPI’s hound-mcp is now v13.2.0 (2026-08-26) and its project metadata points to a different repository (dondai44423/master-fetch). That current README still says “New in 12.1.2” and now tells users to switch to yet another project, a Rust successor called DonSeTch.

The result is a high-churn, self-superseding project rather than a stable foundation. Full evidence is in Part 4.

TL;DR (updated Sep 5, 2026)

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 / master-fetch (hound-mcp, MIT) — a local MCP server with 6 tools (search/fetch/crawl/screenshot) that vendors ddgs as its keyless backbone and adds a stealth browser, circuit breakers, ranking, and a BYOK API layer. No longer recommended as a research foundation; the audit in Part 4 explains why.
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. This is the self-hosted option that survived the audit.
3. ddgs (2.9k★, MIT) — a Python library that aggregates diverse search services. Still 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 (updated): default to SearXNG (self-hosted, keyless IP shield) or official search APIs / MCP servers (Brave, Exa, Perplexity, Tavily, Bright Data) for stable, higher-volume research. Treat Hound as an experiment to sandbox and watch, not as infrastructure: its original repo is a stale snapshot, its current PyPI package has moved accounts, and its own README points users to a successor.

Part 1 — The three candidates

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

• Repo (Aug 2 snapshot): https://github.com/dondai1234/master-fetch — 760★, MIT, Python, created 2026-06-01, active at the time (pushed 2026-07-24).
• Status (Sep 5, 2026): legacy/stale snapshot. No code push to this repo since 2026-07-24; it ends at v12.4.1. PyPI is now v13.2.0 and points to https://github.com/dondai44423/master-fetch. The author’s current README recommends a replacement project (DonSeTch, https://github.com/dondai44423/donsetch), so any assessment of this repo’s code is already behind the shipped package.
• 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.

This section is the original Aug 2 profile. For what the audit found wrong with relying on Hound, see Part 4.

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.

Practical agent-harness notes (Sep 5, 2026):

• Metasearch is the resilience feature. A naive harness that hits one consumer engine with curl maintains its own parser, headers, and CAPTCHA handling. SearXNG puts one JSON API in front of many upstream engines, so per-engine blocking degrades coverage instead of killing the search.
• SearXNG’s own limiter matters. When enabled, per-client-IP defaults are roughly: ~15 requests per 20-second burst, ~150 per 10 minutes, and only ~4 requests/hour for non-HTML (JSON API) requests unless the client is allowlisted. An agent harness should put its own IP/subnet in limiter.toml (pass_ip); pass_ip has priority over the other bot checks.
• Upstream engines are still the real ceiling. There is no published “free traffic” number for SearXNG; consumer engines throttle/captcha based on the server IP’s volume and reputation. A useful planning heuristic: below ~500 queries/day with occasional failures is comfortable; sustained thousands/day, or production reliability requirements, are when per-engine paid API keys (e.g., Brave, Exa API in settings.yml) or official provider APIs start paying off.
• BYOK exists but per-engine, not as a pool manager. SearXNG accepts per-engine API keys in settings.yml for API-backed engines (e.g., Brave, Exa API). That differs from Hound’s centralized key rotation and is simpler: configure the key, and SearXNG calls that engine’s official API instead of scraping it.

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 (Aug 2, 2026 snapshot)

Snapshot caveat: the Hound row describes v12.4.1 of the original repo, verified Aug 2. It predates the v13.x releases, the MCP 2026-07-28 spec work, and the security fixes in the current repo (e.g., the Aug 12, 2026 SSRF redirect/DNS fix). It also predates the author’s own move to a successor project.

Part 3 — Composition and the recommended approach

3.1 The three are layers, not rivals

Official search APIs / MCPs ──▶  your agent CLI      (stable, per-request quota)
SearXNG ──JSON API──▶  your agent CLI                (keyless, server-side IP shield)
ddgs ──▶  DIY wrapper code (or vendored inside Hound) (raw building block, fragile)

3.2 Decision ladder (revised Sep 5, 2026)

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: SearXNG provides the keyless, server-IP-shielded option, while the official provider APIs/MCP servers provide the stable high-volume path. Rate-limit etiquette (Retry-After, backoff, batching, caching) is still the playbook from Part 2 of that article. The one thing no keyless tool can escape — per-IP throttling — is handled by SearXNG’s engine breadth and per-engine API keys, or by using official APIs that never scrape your IP. Hound is no longer needed to get that behavior.

Part 4 — Audit findings (Sep 5, 2026)

The Sep 5 follow-up used the GitHub API, a source clone of the original repo, current PyPI metadata, and both repos’ commit/release histories. The “toy-like / vibe-coded” impression is not baseless:

4.1 The URL originally profiled is already a stale snapshot

• dondai1234/master-fetch: created 2026-06-01, last code push 2026-07-24, ~865★ / 78 forks / 13 open issues on Sep 5, 2026. Its code ends at v12.4.1 (the source clone confirms pyproject.toml = 12.4.1 while the README still says “New in 12.1.2”).
• PyPI hound-mcp is now v13.2.0 (published 2026-08-26), and its project metadata points to a different repository: dondai44423/master-fetch (created 2026-07-30, ~91★, pushed 2026-08-26).
• That current repo’s README still says “New in 12.1.2” while its codebase is at v13.2.0 — more than a major version behind — and now carries a note recommending a successor: DonSeTch (dondai44423/donsetch, Rust/AGPL, created 2026-08-07, ~595★, pushed 2026-09-04). The author’s note says the replacement “is better” but is new enough that “maybe there are some hidden issues.”

4.2 Release churn and “vibe-coded” signals

• 102 PyPI releases between 2026-06-01 and 2026-08-26 (version 2.0.0 → 13.2.0), including active days with 8–24 uploads and commit bursts of 20+ per day. That is product-launch cadence, not stabilization cadence.
• The project went 2.0 → 13.2 in under three months, moved GitHub accounts midstream, and then the author announced a from-scratch rewrite in another language. Each of those alone is survivable; together they mean the “tool” is an experiment in continuous reinvention.
• Marketing-style claims (e.g., a “stealth benchmark” table claiming all-pass on bot-detection sites and bypasses of Cloudflare/DataDome) are not backed by a reproducible benchmark in the repo; the test suite mostly checks internal invariants, and live anti-bot results are not continuously validated by CI.

4.3 Architecture is fragile by design

• Keyless search is scraper-based: vendored ddgs code scrapes DuckDuckGo/Brave/Google/Startpage/etc. with hard-coded parsers, TLS impersonation, fake user agents, and an anti-detect browser for CAPTCHA/Turnstile evasion.
• Search_metasearch even monkeypatches internal httpcore classes for HTTP/2 fingerprint variation. Any upstream change in HTML, rate limiting, or bot detection breaks this class of tool.
• The README is honest that no search-engine ToS compliance is claimed. That is an operational and legal gray zone, not a reliability feature.

4.4 Security and trust caveats

• The v12.4.1 code at the audited URL predates the Aug 12, 2026 SSRF fix (“HTTP redirect + DNS-blind vector, CWE-918”) in the active repo, so its SSRF guard should not be trusted at face value.
• Docker mode exposes an unauthenticated MCP endpoint on 0.0.0.0:8765 by default; the compose file tells users to change it only on trusted networks.
• API keys and proxy credentials are stored as plaintext JSON in ~/.hound (documented in Hound’s own “Known gotchas”).
• The tool ships an anti-detect browser and self-update/repair paths (hound -u, ~/.hound/repair.py) — a large trust surface for a single-maintainer project.

4.5 Fairness check

It is not an empty shell: ~15.8k LOC of source, real tests (700+ test methods), SSRF validation logic, lazy imports, and a genuine known limits section. For a sandboxed personal experiment, Hound can still work. But “can fetch pages on a good day” is not the same as “a stable foundation for agent research.” The current evidence points to SearXNG for keyless self-hosting and official search APIs/MCP servers for volume and stability.

Conclusion

The Sep 5, 2026 audit changes the Aug 2 verdict. Hound/master-fetch is best described as a churn-heavy single-maintainer experiment whose original repo is stale, whose PyPI package has moved to another account, and whose own README now points users to a fresh Rust successor. SearXNG remains the recommended self-hosted metasearch (server-side IP shield, ~274 engines, per-engine API-key support), ddgs remains the raw building block, and the stable path to high-quality/high-volume agent search is official search APIs and their MCP servers. Hound can be used experimentally in a sandbox, but it should not be the default “free search gateway” in a research harness.

References

Hound (master-fetch) — Aug 2 profile (verified Aug 2, 2026)

• 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

Sep 5, 2026 audit (verified by GitHub API and PyPI metadata)

• Original repo metadata/commits (last push 2026-07-24, v12.4.1): https://github.com/dondai1234/master-fetch
• Current PyPI-backed repo (dondai44423/master-fetch, v13.2.0): https://github.com/dondai44423/master-fetch
• PyPI hound-mcp metadata (102 releases, current project URLs): https://pypi.org/pypi/hound-mcp/json
• Author’s announced successor (DonSeTch, Rust/AGPL): https://github.com/dondai44423/donsetch
• Open issues on the original repo (spec violations, crashes, stale bugs): https://github.com/dondai1234/master-fetch/issues

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
• Limiter constants verified Sep 5, 2026 (BURST_MAX=15/20s, LONG_MAX=150/10min, API_MAX=4/h): https://github.com/searxng/searxng/blob/master/searx/botdetection/ip_limit.py
• 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