Open-Source MCP Servers for Web Search

Short answer: choose an MCP server based on who operates the search backend, how queries are handled, deployment effort, and fallback needs. Brave Search MCP is the straightforward vendor-API adapter. mcp-searxng is for teams that already operate or trust a SearXNG instance. web-search-mcp is the broadest multi-provider option when fallback or provider choice matters. The available documentation does not establish a universal winner for relevance, latency, uptime, security, or cost.

What an MCP web-search server does

Model Context Protocol (MCP) lets an AI client call tools exposed by a server. In this case, the MCP server translates a tool call into one or more web-search requests and returns structured results to the client.

The MCP server and search backend are separate components:

• Brave Search MCP: an MCP implementation that calls the Brave Search API.
• mcp-searxng: an adapter that connects to an existing SearXNG service; it does not install SearXNG for you.
• web-search-mcp: a multi-provider project listing Tavily, Brave, Exa, Serper, SearXNG, and DuckDuckGo, with fallback and optional ensembling.

Comparison at a glance

Server	Backend model	Deployment	Useful when	Watch-outs
Brave Search MCP	Brave Search API	Local STDIO by default; HTTP can be selected by configuration	You want a documented, single-provider integration with several search categories	Requires Brave credentials and depends on that API
mcp-searxng	Your chosen SearXNG instance	Run or obtain an instance with JSON search enabled	You want control over the search service or already run SearXNG	Privacy depends on the instance operator; setup work remains yours
web-search-mcp	Configurable multi-provider set	Configure provider keys and routing	You need provider fallback, optional ensembling, URL fetching, or reranking	Feature and security claims are project-authored; no independent benchmark was found

1. Brave Search MCP

Brave’s repository documents web search plus local-business, place, image, video, news, LLM-context, and AI-summary capabilities. It uses STDIO as the default transport in the 2.x line, with HTTP selectable through an environment variable or runtime argument. Setup requires a Brave Search API key.

Typical configuration shape

{
  "mcpServers": {
    "brave-search": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-brave-search"],
      "env": {
        "BRAVE_API_KEY": "YOUR_BRAVE_API_KEY"
      }
    }
  }
}

Use the repository’s current package name and arguments when installing; package names and startup flags can change. Keep the key in an environment variable or secret manager, never in a checked-in client file.

When to select it

• Your organization accepts a vendor API as the backend.
• You prefer a single provider and documented category-specific tools.
• Your MCP client works well with local STDIO processes.

2. mcp-searxng

mcp-searxng is a client-facing MCP adapter. You must provide an existing SearXNG instance with JSON search enabled; the integration does not deploy SearXNG.

{
  "mcpServers": {
    "searxng": {
      "command": "python",
      "args": ["-m", "mcp_searxng"],
      "env": {
        "SEARXNG_URL": "https://your-searxng.example"
      }
    }
  }
}

Treat this as a configuration pattern and follow the project’s current installation instructions for the actual command and package. The documented integration includes pagination and URL reading.

Privacy and operating responsibility

An operator-controlled instance can avoid trusting a third-party search operator. A public instance receives the query and may log it. The project explicitly cautions: “SearXNG and this MCP integration do not by themselves provide anonymity.” Review the instance’s logging, upstream engines, retention, access controls, and network path before sending sensitive queries.

3. web-search-mcp

web-search-mcp lists Tavily, Brave, Exa, Serper, SearXNG, and DuckDuckGo backends. Its documented capabilities include provider fallback, optional ensembling, local reranking, URL fetching, and defenses against prompt injection in fetched content.

{
  "mcpServers": {
    "web-search": {
      "command": "node",
      "args": ["/path/to/web-search-mcp/dist/index.js"],
      "env": {
        "TAVILY_API_KEY": "YOUR_TAVILY_KEY",
        "BRAVE_API_KEY": "YOUR_BRAVE_KEY",
        "EXA_API_KEY": "YOUR_EXA_KEY"
      }
    }
  }
}

Configure only the providers you are entitled to use. If you enable fallback, define which provider is preferred, which failures trigger a retry, and how much additional latency or cost a second request may add.

How to choose

1. Identify the backend owner. Pick an external API, an instance your team controls, or a configurable provider set.
2. Map query sensitivity. Decide whether searches may contain customer data, internal project names, or credentials. Apply redaction before the MCP call.
3. Choose transport. STDIO is convenient for a local client. HTTP can suit a shared service, but requires authentication, network controls, and monitoring.
4. List required tools. Search alone may be enough. URL reading, pagination, local or news search, reranking, and fetching can change the choice.
5. Define failure behavior. Decide whether to retry, use a fallback provider, return partial results, or ask the model to continue without search.
6. Check evidence. Repository feature lists are not performance benchmarks. Measure relevance, latency, failure rate, and cost with your own representative queries.

Running an MCP search safely

Input handling

• Validate query length and allowed domains for URL-reading tools.
• Remove secrets, access tokens, and personal data before dispatch.
• Set timeouts for provider calls and cap result counts.
• Keep fetched-page content clearly separated from trusted instructions. Treat it as untrusted data.

Transport controls

For STDIO, restrict which local users can launch the process and where logs are written. For HTTP, require authentication, use TLS, restrict origins, rate-limit requests, and avoid exposing an unauthenticated search endpoint.

Testing and evaluation checklist

• Create a fixed query set covering navigational, technical, current-events, local, and ambiguous searches.
• Record result relevance, duplicate rate, response time, provider errors, and token size returned to the model.
• Test empty results, malformed queries, provider timeouts, HTTP 429 responses, and unavailable backends.
• Verify that fallback does not repeat expensive requests indefinitely.
• Inspect logs for accidental query or credential disclosure.
• Recheck licenses, repository activity, dependencies, API terms, and setup instructions before production adoption.

Performance, reliability, and cost

The reviewed sources provide no independent comparison of relevance, latency, uptime, security under testing, or total cost. Provider count alone does not prove better results. Fallback can improve availability while increasing requests, latency, and spend. Self-hosting can change who receives queries, but it adds maintenance, capacity planning, updates, and monitoring. Record provider usage separately so a multi-provider deployment has an auditable cost profile.

Troubleshooting

The client cannot start the server

Check the executable, package installation, working directory, runtime version, and environment-variable names. Run the command directly in a terminal and read stderr before debugging the MCP client.

Authentication errors

Confirm the key belongs to the configured provider, has not expired, and is available to the process environment. Do not paste keys into JSON committed to source control.

SearXNG returns no results

Verify that the configured instance is reachable and that its JSON API is enabled. Check the instance’s enabled engines and rate limits. Remember that mcp-searxng does not install or configure the instance.

HTTP transport works locally but not remotely

Check bind address, firewall rules, TLS termination, authentication headers, and reverse-proxy timeouts. Keep the service private until these controls are in place.

Fallback causes slow responses

Use short per-provider timeouts, retry only transient failures, and cap the number of fallback attempts. Return the provider name and failure reason in internal telemetry.

Fetched pages contain malicious instructions

Treat page text as untrusted content. Preserve the boundary between tool output and system or developer instructions, and retain the project’s documented injection defenses where available.

Or skip the browser setup

If your agent also needs visual verification, ScreenshotNeo provides a website screenshot MCP server alongside its API. It can remove cookie and consent banners, newsletter popups, and chat widgets before capture; bot checks, blank pages, failed loads, timeouts, and cache hits are not billed; and its MCP tools include take_screenshot, get_page_info, and capture_pdf.

One request returns an image or PDF:

curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webp

import requests
r = requests.get("https://api.screenshotneo.com/v1/shot", params={"access_key": "YOUR_API_KEY", "url": "https://stripe.com"}, timeout=90)
open("shot.webp", "wb").write(r.content)

const q = new URLSearchParams({ access_key: 'YOUR_API_KEY', url: 'https://stripe.com' });
const res = await fetch(`https://api.screenshotneo.com/v1/shot?${q}`);

See the ScreenshotNeo API documentation for the full option set. The free plan includes 1,000 screenshots each month with no card; paid plans start at $5 for 3,000 shots. Create a free ScreenshotNeo account.

FAQ

Is an MCP server itself a search engine?

No. It is an adapter that exposes search capabilities to an MCP client; a separate backend performs the search.

Does self-hosting SearXNG guarantee anonymity?

No. The mcp-searxng documentation says neither SearXNG nor the integration provides anonymity.

Which server has the best results?

The reviewed material does not provide an independent search-quality benchmark. Evaluate with your own query set.

Can I use several providers at once?

web-search-mcp documents fallback and optional ensembling. Configure limits and budgets so multiple requests do not create unexpected latency or cost.

Should I use STDIO or HTTP?

Use STDIO for a local client and HTTP when a controlled shared service is required. HTTP needs authentication, TLS, network restrictions, and monitoring.