Grounder › Guides › MCP web search server

MCP web search server: what it is and the options

Published July 27, 2026 · Last updated July 2026

An MCP web search server is a Model Context Protocol server that gives an AI agent live web search as a callable tool. There is no single "official" one: the real options are vendor-maintained servers - Brave, Tavily, Exa, Firecrawl, no-key DuckDuckGo community servers, and Grounder, which exposes four tools (search, fetch, deep_search, research) over MCP and a plain REST API. This page defines the concept, explains why there is no one blessed server, lists the real options by category, shows Python and Node code, and gives a measured Grounder-vs-Tavily head-to-head that says where Tavily is the better choice.

Transparency note: we build Grounder, one of the servers listed here, so we have a commercial interest. We have aimed for accuracy, and the only hard numbers on this page are our own Grounder-vs-Tavily benchmark - where Tavily wins the coverage axis. Every other server and vendor is described by category, not by numbers we did not measure. Always verify current pricing, limits, and tool parameters against each project's official documentation.

What is an MCP web search server?

An MCP web search server is a Model Context Protocol server whose tools are web search and, usually, page fetching. The Model Context Protocol is an open standard for connecting an LLM to outside systems: a server advertises a set of typed tools, an MCP client (Claude Desktop, Cursor, an IDE agent, or your own loop) discovers them, and the model decides when to call one during a conversation. A web search MCP server turns "search the web" into a structured tool call - the model emits a query, the server runs the search against a real index or scraper, and it returns titles, URLs, snippets, and often the page contents in a shape the model can read and cite. The point is that you stop writing bespoke glue between your agent and a search API: any MCP-aware client can pick the server up, list its tools, and use them the same way it uses a filesystem or database server. That standardization is the whole reason the category exists - one protocol, many interchangeable search backends.

What are MCP servers, in one paragraph?

MCP servers are programs that expose tools (functions the model can call), resources (data the model can read), and prompts (reusable templates) to an AI model over the Model Context Protocol. The protocol was published as an open standard and has reference implementations plus a growing ecosystem of community and vendor servers. A server might wrap a database, a Git repository, a filesystem, a payments API - or web search. On the other side sits an MCP client embedded in the agent or chat app; it connects to one or more servers, lists their capabilities, and lets the model invoke them. So a "web search MCP server" is not a special kind of thing - it is an ordinary MCP server whose advertised tools happen to be search and fetch. If you want the wider catalogue, community directories index hundreds of servers across every category; this page is only about the web-search ones.

Is there an official MCP web search server?

No single official one. The Model Context Protocol project maintains a set of reference servers to demonstrate the protocol, and that set historically included a Brave Search example (the @modelcontextprotocol/server-brave-search package). But a reference example is not a blessed, supported "official web search server" for every agent, and search examples have moved between the reference repo and vendor-owned repos over time. What actually exists is a field of vendor-maintained servers, each wrapping that vendor's own search product:

• Brave publishes its own Brave Search MCP server, backed by its independent index.
• Tavily, Exa, and Firecrawl each ship a first-party MCP server for their API.
• DuckDuckGo-based and SearXNG-based community servers run with no API key at all.
• Grounder (ours) is a vendor server exposing four tools over MCP and a REST API.

So the honest answer to "which is the official one" is: there isn't one to point at. Pick the server whose search backend matches your job, because that - not an official stamp - is what determines coverage and result quality.

A list of MCP servers for web search (the real options)

Below is the practical list, grouped by what the underlying search backend actually returns. The free-tier and pricing cells are directional only - verify current terms on each vendor's page.

For the same list read through the local-model lens - including the no-API-key DIY servers - see the best web search MCP servers for local LLMs.

Web search MCP servers for AI, by category

The servers above are not interchangeable. They split by what their backend does, and that split is the thing to choose on.

Independent index: Brave

Brave Search MCP is backed by Brave's own crawl and index rather than reselling Google. Best for a stable, independent raw-search leg you wire into an agent. The catch: it returns links and snippets - the read, rank, and fit-to-window work is still yours.

LLM-tuned search plus an answer: Tavily

Tavily MCP returns web results plus a short synthesized answer and has by far the largest distribution in this space. Best for a mature, well-supported default. The catch: metered per call, and results come back at whatever length rather than capped to a context budget. Its measured strength and weakness against Grounder are in the head-to-head below.

Neural/semantic recall: Exa

Exa MCP is tuned for meaning-based recall - finding pages where the answer is phrased differently from the query. Best for semantic retrieval. The catch: metered, and if you need a token-capped pack you build that yourself.

Scrape-first extraction: Firecrawl

Firecrawl MCP is more read than find - it turns pages into clean, LLM-ready markdown and can scrape the top results. Best for content extraction and building a RAG corpus. The catch: it hands back whole pages, so a small model's window still needs your chunking.

No API key: DuckDuckGo and SearXNG community servers

Community MCP servers built on DuckDuckGo or a self-hosted SearXNG instance run with no API key. Best for zero cost and no signup. The catch: coverage and stability - they scrape or hit public endpoints, can rate-limit, and leave the fetch/rank/fit steps to you.

Grounder as an MCP web search server: four tools

Grounder is the token-capped, flat-billed option, and it covers the whole retrieval arc rather than stopping at "find the links." It runs as an MCP server and, identically, as a plain REST API. Four tools:

• web_search - Google results with snippets, plus people_also_ask and a knowledge_graph panel. One page, no LLM. This is the raw "find the sources" leg.
• fetch - one page to clean markdown; pass an optional query and it returns verbatim ranked passages instead of the whole page. Token-capped with max_tokens, and scoped to domains a recent search returned.
• deep_search - searches, reads up to about ten of the top pages, chunks and MMR-ranks them, and returns a token-capped cited passage pack. Optional include_answer.
• research - an agentic loop: plan, search, read, ask "what am I missing?", repeat. It runs as a background poll job and is billed one run against a monthly allowance.

The differentiator is the cap. Every response is sized to your context window with max_tokens, which is the axis most of the servers above leave to you - a search server hands back results at any length; a scraper hands back a whole page.

Grounder vs Tavily, measured (and where Tavily wins)

Tavily is the natural baseline: it is the most-installed web search MCP server, and it is a fair, well-supported default. Here is the honest head-to-head, including the axis where Tavily is ahead.

Hard-page coverage: Tavily wins. On 19 deliberately hard targets, Tavily read 13 and Grounder read 10. g2.com is the clearest case - Tavily returns it and Grounder cannot read it at any setting. If your workload is dominated by bot-walled pages, Tavily is the better tool.

Answers per token: Grounder wins. Across 37 real pages scored on whether the sentence that answers the query survives into the returned passages, Grounder found 30 answers in 65.7k characters against Tavily's 26 in 76.6k. More answers, less context - which matters most where a small window cannot afford navigation and boilerplate.

Billing and privacy. Tavily meters per call; Grounder is a flat monthly price with a page budget, so an agentic loop that reads hundreds of pages does not change your bill. Grounder stores per-key billing counters and a domain on retrieval events, never the query, the path, or who asked. A page it could not read returns 422 fetch_failed with a reason and is not charged.

Known limitations of Grounder as an MCP web search server

The section most vendor pages skip. Every one of these is a real reason to pick a different server:

1. Tavily reads more of the hard web - 13/19 vs Grounder's 10/19 on hard targets, so Grounder is third on hard-page access in our own run.
2. Grounder cannot read g2.com at any setting; Tavily can. Review-site-heavy workloads should use Tavily.
3. Grounder resells a discovery vendor - it does not run its own index like Brave or Tavily, so it inherits that vendor's coverage limits.
4. Near-zero distribution - Tavily has a large SDK ecosystem and many framework integrations; Grounder has an MCP server and a REST API and little else.
5. Flat pricing is not cheapest-per-call - for tiny or occasional use, Serper or a self-hosted SearXNG server costs less.
6. No neural/semantic recall - if you need meaning-based retrieval, Exa is purpose-built for it and Grounder is not.

Which MCP web search server to pick

• An independent index, wired yourself → Brave Search MCP.
• A mature default with a synthesized answer, or bot-walled pages are the job → Tavily.
• Meaning-based / semantic recall → Exa.
• Turn pages into clean markdown for RAG ingestion → Firecrawl.
• No API key, zero cost, will accept flakiness → a DuckDuckGo or self-hosted SearXNG community server.
• A cited pack that fits a small window, on a flat bill, storing no queries → Grounder.

Connecting a web search MCP server: Python and Node

Over MCP, Grounder's tools (web_search, fetch, deep_search, research) register in any MCP client and the model calls them directly. The identical surface is a REST API when you want to call it from code, so the two examples below hit the endpoints straight. The flow is a search for links, then a token-capped cited pack.

Python (production-shaped: env key, timeout, error surface):

import os
import requests

BASE = "https://grounder.dev"
HEADERS = {
    "Authorization": f"Bearer {os.environ['GROUNDER_KEY']}",
    "Content-Type": "application/json",
}

def search(query: str, timeout: float = 30.0) -> dict:
    """Raw links + snippets - the 'find the sources' leg (one page)."""
    r = requests.post(
        f"{BASE}/v1/search",
        json={"query": query},
        headers=HEADERS,
        timeout=timeout,
    )
    r.raise_for_status()          # 4xx/5xx -> exception, not silent bad data
    return r.json()

def deep_search(query: str, max_tokens: int = 600, timeout: float = 60.0) -> dict:
    """Token-capped, cited evidence pack sized to your context window."""
    r = requests.post(
        f"{BASE}/v1/deep_search",
        json={"query": query, "max_tokens": max_tokens},
        headers=HEADERS,
        timeout=timeout,
    )
    r.raise_for_status()
    return r.json()

if __name__ == "__main__":
    pack = deep_search("mcp web search server options")
    for p in pack["passages"]:
        print(f"[{p['score']}] {p['url']}\n{p['text']}\n")

Node.js (same flow, native fetch, explicit error on non-2xx):

const BASE = "https://grounder.dev";
const HEADERS = {
  "Authorization": `Bearer ${process.env.GROUNDER_KEY}`,
  "Content-Type": "application/json",
};

async function call(path, body) {
  const res = await fetch(`${BASE}${path}`, {
    method: "POST",
    headers: HEADERS,
    body: JSON.stringify(body),
  });
  if (!res.ok) {
    throw new Error(`grounder ${res.status}: ${await res.text()}`);
  }
  return res.json();
}

const links = await call("/v1/search", { query: "mcp web search server options" });
const pack = await call("/v1/deep_search", {
  query: "mcp web search server options",
  max_tokens: 600,
});
for (const p of pack.passages) {
  console.log(`[${p.score}] ${p.url}\n${p.text}\n`);
}

Full tool parameters, the MCP client config, and fetch/research are in the docs.

Related guides

• The best web search MCP servers for local LLMs The same servers through the local-model lens, plus the no-API-key DIY options.
• Tavily alternatives for AI agents and RAG Exa, Firecrawl, Linkup, Brave, SearXNG, Serper, and Grounder compared as APIs, not MCP servers.
• Why your local LLM returns nothing on a web page The small-window overflow failure, measured, and the token-capped fix these servers do or don't do.

FAQ

Methodology: hard-page numbers from bench/hardweb.py, passage numbers from a 37-page rerank corpus, both run 2026-07-22. All non-Grounder servers are described by category only, not by numbers we did not measure; verify each vendor's current pricing and limits on its own page. Grounder is a young product reselling a discovery vendor, with near-zero distribution next to Tavily's ecosystem - that gap is real and is the honest cost of picking it today. Last updated July 2026 - see the docs for current parameters.