Ideas
TinySearch vs. Tavily, Exa, Perplexity Sonar, and Brave Search API
If you’re evaluating web search for an AI agent, you’ve likely already looked at Tavily, Exa, Perplexity’s Sonar API, or Brave’s Search API. All four are solid, all four ship official MCP servers, and all four require an API key and bill per request. TinySearch is built around a different premise: the search backend can be free and local, and the part worth paying engineering attention to is what happens to the results after they come back.
They all have MCP servers. That’s not the differentiator.
It’s worth correcting a common assumption up front. Tavily, Exa, Perplexity, and Brave each publish an open-source MCP server (tavily-ai/tavily-mcp, exa-labs/exa-mcp-server, perplexityai/modelcontextprotocol, brave/brave-search-mcp-server), and all of them run as a local process over stdio, the same way TinySearch does. If your mental model is “hosted APIs don’t have MCP support,” that’s out of date.
What those servers don’t change is where the actual work happens. Each one is a thin client: it takes the tool call, attaches your API key, and proxies the request to the vendor’s cloud. The MCP server is local. The index, the crawling, and the billing meter are not. TinySearch’s server and its search backend both run on your machine, which is the part that actually matters for cost, rate limits, and data leaving your network.
What each one does differently
Tavily positions itself explicitly as the search and extraction layer for RAG and agent workflows, with separate Search, Extract, Crawl, Map, and an agentic Research endpoint. Pricing is credit-based, with a monthly free allotment and pay-as-you-go credits beyond it; a basic search costs a fraction of a credit, and the newer Research mode costs substantially more per call since it runs its own multi-step agent behind the scenes.
Exa is a neural search engine: instead of matching keywords, it embeds the query and matches it against embedded pages, which is a genuinely different retrieval approach from a traditional index. It’s priced per request across separate endpoints for search, contents, and an answer mode, with page contents for the first several results now bundled into a search call. There’s no self-hosted option; the index itself only exists in Exa’s cloud.
Perplexity’s Sonar API is the most mechanically different of the four: it’s an LLM inference endpoint that searches and returns a written, cited answer, not a set of ranked documents. You’re billed for tokens plus a separate per-request search fee that scales with how much search context the model pulls in. That’s a genuinely useful shape if you want an answer and don’t have your own model in the loop, and a less useful one if you already do and want to write the answer yourself.
Brave Search API is built on Brave’s own independent index rather than reselling Google or Bing, which is its main pitch. It returns raw results by default, with a separate Answers endpoint for summarized, cited responses if you want them. Pricing is per-1,000-requests with a small monthly free credit.
None of the four offer a way to run their index yourself. That’s a reasonable business model, not a flaw, but it means every one of them ties your agent’s research step to a vendor’s uptime, pricing changes, and rate limits, no matter how local the MCP server feels.
What TinySearch does instead
TinySearch runs the whole pipeline, search included, on infrastructure you control: a stdio MCP server, a Python library, or a self-hosted Docker stack. The native install needs no API key and no account. DDGS backs search by default, a bundled SearXNG instance is available for the Docker path, and Brave’s Web Search API can be configured as an optional keyed fallback if the free backends error out.
The output is also a different shape from three of the four vendors above. search(query) does fast top-level discovery, and scrape_urls(items) crawls the pages worth opening and returns ranked, chunked evidence with source URLs attached, the same kind of grounded context you’d hand-assemble yourself for a RAG prompt, and stops there. Your own client model reads that evidence and writes the answer, so the citation trail runs from your model’s claim back to the actual passage that supports it, not to a paraphrase written by a model you don’t control and didn’t choose.
Concretely, that means a claim in your agent’s final answer can be traced to one specific chunk, from one specific URL, that was ranked highly enough against your exact query to survive TinySearch’s cutoff. With an answer-mode API, the trace stops at “the vendor’s model said this, and cited these pages while saying it,” which is a weaker guarantee if something in the answer turns out to be wrong.
| TinySearch | Tavily / Exa | Perplexity Sonar | Brave Search API | |
|---|---|---|---|---|
| Search infrastructure | Self-hosted (DDGS, SearXNG, or Brave fallback) | Hosted | Hosted | Hosted |
| MCP server location | Local | Local (proxies to cloud) | Local (proxies to cloud) | Local (proxies to cloud) |
| Auth | None by default | API key | API key | API key |
| Billing | None | Per credit / request | Tokens + search fee | Per 1,000 requests |
| Output | Ranked, chunked evidence with citations | Results, or a written answer (Research mode) | Written answer with citations | Raw results, or a written answer (Answers endpoint) |
| Extra LLM call baked in | No | Sometimes | Yes, always | Sometimes |
When the hosted option is the better call
None of this makes Tavily, Exa, Perplexity, or Brave the wrong choice. Exa’s neural retrieval finds pages a keyword search would miss. Perplexity’s Sonar API is the fastest path to a cited answer if you don’t want to run a model of your own. All four give you a maintained index without operating a crawler or a search service yourself, and if your usage is low enough, the free tier costs less than the engineering time it’d take to self-host.
TinySearch is the better fit when you already have a capable model in your agent and want the research step to cost nothing beyond compute, stay inside your own infrastructure, and hand that model raw, checkable evidence instead of an answer it didn’t produce.
A quick way to decide
If your team is already comfortable paying per request for a maintained index and wants an answer written for you, Perplexity’s Sonar API is the shortest path there, and Tavily’s Research mode covers similar ground with more control over the underlying steps. If you need retrieval that finds conceptually related pages a keyword match would miss, Exa’s neural search does that job well, at its own per-request price. If an independent index matters to you for reasons beyond agent search, Brave’s API is worth a look regardless of which research shape you pick.
If none of those tradeoffs apply, meaning you have a capable model already, you don’t want a per-call bill attached to every research step, and you’d rather your agent’s citations point at real retrieved text, TinySearch is built for exactly that case. Install TinySearch or read the full pipeline breakdown.