Skip to main content
Glama

free-search-mcp

License Python MCP

Un servidor del Protocolo de Contexto de Modelo (MCP) local y sin necesidad de clave API que ofrece a cualquier LLM (Claude, GPT, Ollama local, …) la capacidad de buscar en la web, obtener y limpiar páginas, y leer documentos, sin que tengas que registrarte en ninguna API de búsqueda.

Reúne las mejores ideas de varios MCP de código abierto en un único paquete de Python y añade la ergonomía para LLM y la fiabilidad que a cada uno de ellos les faltaba.

research("how does reciprocal rank fusion work", depth=3)
   ↓
# Research brief: how does reciprocal rank fusion work
_engines: duckduckgo, mojeek, startpage · sources: 3 · ~3,400 tokens_

## Sources
- [1] Reciprocal rank fusion | Elasticsearch Reference — <https://…>
- [2] Hybrid Search Scoring (RRF) | Microsoft Learn — <https://…>
- [3] RRF explained in 4 mins — Medium — <https://…>

## Documents
…full Markdown bodies of each page, ready for the LLM to read…

Una llamada de herramienta. Tres fuentes. Sin clave API. Sin el chantaje de OPENAI_API_KEY-pero-para-búsqueda.


Por qué existe esto

Los MCP de búsqueda existentes hacen bien una cosa, pero normalmente quieres todo esto:

Multi-motor

Sin clave API

Alternativa inteligente

PDF/DOCX

Caché FTS5

Filtros

Trafilatura

Optimizado para LLM

nickclyde/duckduckgo-mcp-server

✗

✓

✗

✗

✗

✗

✗

~

mrkrsl/web-search-mcp

✓

✓

✓

✗

✗

✗

✗

~

Aas-ee/open-webSearch

✓

✓

~

✗

✗

✗

✗

~

VincentKaufmann/noapi-google-search-mcp

✗

✓

✓

✓

✓

✗

✗

~

free-search-mcp

✓

✓

✓

✓

✓

✓

✓

✓

"Optimizado para LLM" significa aquí: salida centrada en Markdown, estimaciones de tokens, truncamiento inteligente en los límites de los párrafos, docstrings de "Mejor para / No es para / Devuelve / Errores comunes" que el modelo utiliza para elegir la herramienta correcta, sugerencias de error accionables, prompts de MCP y plantillas de recursos, y una función research() de un solo paso que colapsa búsqueda→obtención→obtención→obtención en un solo turno.

"Trafilatura" significa que extraemos el contenido principal usando trafilatura, ganador del benchmark ROUGE de Bevendorff 2023 (~0.85 frente a ~0.55 para la eliminación ingenua de código repetitivo). Cada página obtenida también devuelve author, published_date y sitename de forma gratuita.

"Filtros" significa que la búsqueda/investigación acepta freshness, include_domains, exclude_domains, category (news/pdf/github/paper/forum/blog), include_text, exclude_text.


Related MCP server: uvxwebsearchmcp

Herramientas

Herramienta

Descripción

search(query, engines?, max_results?, use_cache?, max_age_hours?, freshness?, include_domains?, exclude_domains?, category?, include_text?, exclude_text?, format?)

Búsqueda paralela en múltiples motores fusionada mediante Reciprocal Rank Fusion

research(question, depth?, engines?, fetch?, use_cache?, max_age_hours?, freshness?, include_domains?, exclude_domains?, category?, include_text?, exclude_text?, format?)

Un solo paso: buscar + obtener los N mejores + devolver resumen en Markdown

fetch(url, render?, force_refresh?, max_age_hours?, format?)

Obtener una página, devolver Markdown en modo lectura (extraído con trafilatura, con autor/fecha/nombre del sitio)

fetch_batch(urls, render?, format?)

Obtención concurrente de múltiples URL

read_doc(source, start?, length?, format?)

Analizar PDF / DOCX / HTML / TXT / MD con paginación

cache_search(query, limit?, format?)

Búsqueda FTS5 en páginas obtenidas previamente

engines()

Listar nombres de motores disponibles para search

Además de 2 prompts de MCP (Research thoroughly, Fact-check claim) y una plantilla de recurso (cache://page/{url}) para arrastrar páginas cacheadas de vuelta al contexto sin volver a obtenerlas.

Filtros (search / research)

Parámetro

Valores

Efecto

freshness

day / week / month / year

Solo resultados de los últimos N

include_domains

["python.org", "djangoproject.com"]

Restringir a estos dominios

exclude_domains

["pinterest.com"]

Eliminar estos

category

news / pdf / github / paper / forum / blog

Atajo de tipo de contenido (paper = arxiv/acm/ieee/…, forum = reddit/HN/SE, etc.)

include_text

"async"

Subcadena requerida en título/fragmento

exclude_text

"beginner"

Subcadena prohibida

max_age_hours

24

Sobrescribir el TTL de caché predeterminado de 7 días en esta llamada

Todas las herramientas usan por defecto format="markdown": legible, ~40% menos tokens que JSON, con procedencia y un encabezado de presupuesto de tokens. Pasa format="json" para acceso estructurado.

Anotaciones de herramientas

Cada herramienta incluye las anotaciones correctas readOnlyHint, idempotentHint y openWorldHint para que los clientes MCP puedan etiquetarlas y controlar acciones elevadas.

Motores

Conjunto predeterminado (todos fiables, sin captchas durante llamadas repetidas): duckduckgo, mojeek, startpage.

Opcionales (desafíos intermitentes para clientes headless): brave, bing, baidu.

Brave/Bing/Baidu bloquean navegadores headless después de un puñado de llamadas (CAPTCHAs PoW, páginas de "algo salió mal", envoltorios de redirección). Pasa engines=["brave"] etc. solo cuando los predeterminados no encuentren lo que necesitas.


Instalación

git clone https://github.com/ymylive/free-search-mcp.git
cd free-search-mcp
uv sync
uv run playwright install chromium

Ejecutar como servidor independiente (transporte stdio):

uv run search-mcp

Ejecutar pruebas en vivo (accede a la web real; configura la variable de entorno):

SEARCH_MCP_TEST_NETWORK=1 uv run pytest -v

Las pruebas offline se ejecutan por defecto y no tocan la red.


Conectar a Claude Desktop

Añade esto a ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) o el equivalente en tu plataforma:

{
  "mcpServers": {
    "search": {
      "command": "uv",
      "args": ["--directory", "/absolute/path/to/free-search-mcp", "run", "search-mcp"]
    }
  }
}

Reinicia Claude Desktop. Las siete herramientas anteriores aparecerán en el cajón de herramientas.

Conectar a otros clientes

El servidor habla MCP estándar a través de stdio. Todo lo que soporte MCP funciona:

  • Claude Code (claude mcp add search uv --directory /…/free-search-mcp run search-mcp)

  • Cursor / Continue / Cline (usa el fragmento JSON anterior)

  • Clientes personalizados de Python / TypeScript a través del SDK oficial de MCP


Configuración

Todos los ajustes pueden ser sobrescritos por variables de entorno con el prefijo SEARCH_MCP_:

Var

Predeterminado

Significado

SEARCH_MCP_DEFAULT_ENGINES

["duckduckgo","mojeek","startpage"]

Lista JSON

SEARCH_MCP_MAX_RESULTS_PER_ENGINE

10

SEARCH_MCP_RATE_LIMIT_PER_MINUTE

30

por motor

SEARCH_MCP_FETCH_RATE_LIMIT_PER_MINUTE

20

bucket compartido de fetch

SEARCH_MCP_CACHE_DIR

~/.cache/search-mcp

SEARCH_MCP_CACHE_TTL_SECONDS

604800

7 días

SEARCH_MCP_FETCH_STRATEGY

auto

auto / http / browser

SEARCH_MCP_BROWSER_HEADLESS

true

SEARCH_MCP_BROWSER_POOL_SIZE

2

páginas concurrentes

SEARCH_MCP_MAX_CONTENT_CHARS

50000

truncamiento por resultado


Arquitectura

   ┌─────────────────────────────────────────────────────┐
   │  FastMCP server (stdio)                             │
   │  tools: search / research / fetch / fetch_batch /   │
   │         read_doc / cache_search / engines           │
   └────────────┬────────────────────────────────────────┘
                │
   ┌────────────▼────────────┐  ┌────────────────────────┐
   │  aggregator             │  │  fetcher               │
   │  - parallel engines     │  │  - httpx fast path     │
   │  - reciprocal rank      │  │  - playwright fallback │
   │    fusion               │  │  - markdownify         │
   │  - search cache (FTS5)  │  │  - page cache (FTS5)   │
   └────┬────────────────────┘  └────────────┬───────────┘
        │                                    │
   ┌────▼─────────────────┐  ┌──────────────▼─────────────┐
   │  engines/            │  │  browser pool              │
   │   duckduckgo.py      │  │   - persistent context     │
   │   mojeek.py          │  │   - stealth init script    │
   │   startpage.py       │  │   - shared cookies         │
   │   brave.py     (opt) │  │   - semaphore-bounded pages│
   │   bing.py      (opt) │  └────────────────────────────┘
   │   baidu.py     (opt) │
   └──────────────────────┘

   ┌────────────────────────────┐    ┌──────────────────┐
   │  documents/                │    │  ratelimit       │
   │   pypdf, python-docx,      │    │   token bucket   │
   │   markdownify              │    │   per engine     │
   └────────────────────────────┘    └──────────────────┘

   ┌────────────────────────────┐    ┌──────────────────┐
   │  formatting                │    │  research        │
   │   token estimate           │    │   composed       │
   │   smart truncation         │    │   workflow       │
   │   markdown renderers       │    │                  │
   └────────────────────────────┘    └──────────────────┘

Patrón de adaptador de motor

Cada motor en src/search_mcp/engines/ implementa:

class Engine:
    name: str
    needs_browser: bool          # Force Playwright?
    wait_selector: str | None    # CSS to wait for in browser mode

    def build_url(self, query: str, max_results: int) -> str: ...
    def parse(self, html: str) -> list[SearchResult]: ...

La clase base maneja el transporte (httpx → alternativa Playwright), la limitación de tasa y el caso en que HTTP devuelve un shell de captcha en lugar de resultados (reintentos automáticos a través del navegador).


Créditos

Este proyecto se apoya en los hombros de:


Licencia

MIT — ver LICENSE.

Available Tools

11 tools
compareCompare URLs side-by-sideA
Read-onlyIdempotent

Fetch 2-5 URLs concurrently and return per-URL excerpts so the LLM can compare them against a single question in one round trip.

Best for:
- Side-by-side product/feature/article comparisons.
- "Compare X to Y" or "How does A differ from B" queries.
- Triangulating a fact across multiple sources.

Not recommended for:
- >5 URLs -> use `fetch_batch`.
- 1 URL -> use `fetch`.
- Don't have URLs yet -> use `search` or `research` first.

Returns:
- markdown (default): a comparison brief with per-URL sections, each
  containing title, sitename, published date, and a smart-truncated excerpt.
- json: {question, urls, excerpts:[{url, title, excerpt, ...}],
  tokens_estimated}.

Common mistakes:
- Asking `compare` to actually answer the question: it returns material,
  the LLM does the comparison.
- Passing >5 URLs and expecting them all to fit in context: use
  `fetch_batch` for bulk reads.

Args:
    question: The comparison question the LLM will answer using the
        returned excerpts.
    urls: 2-5 absolute http(s) URLs.
    format: "markdown" (default) or "json".

Inputs: urls (required), question (required), format.

downloadDownload a file to diskA
Idempotent

Save a file from a URL to a local, auto-expiring download directory.

Downloads are enabled by default and saved under
`SEARCH_MCP_CACHE_DIR/downloads`. Set `SEARCH_MCP_DOWNLOAD_ENABLED=false`
to disable them or `SEARCH_MCP_DOWNLOAD_DIR` to override the destination.

Best for:
- Keeping an actual file (installer, dataset, archive, image) rather than
  its text.
- Handing a path to another tool that needs a real file on disk.

Not recommended for:
- Reading a document's contents -> use `read_doc`, which parses it without
  touching the filesystem.
- Looking at a web page -> use `fetch`.
- Viewing an image -> use `fetch(inline=True)`.

Returns:
- markdown (default): where the file was saved, its size and type.
- json: {url, saved_path, media_type, bytes_size, sha256, expires_in_hours}.
  An expires_in_hours value of 0 means TTL cleanup is disabled.

Retention: files older than SEARCH_MCP_DOWNLOAD_TTL_HOURS (default 24) are
deleted before the next download and at startup. A value of 0 disables TTL
cleanup. Otherwise, treat the path as short-lived and copy it elsewhere if
you need to keep it.

Args:
    url: Absolute http(s) URL of the file to save.
    format: "markdown" or "json".

Inputs: url (required), format.

enginesList available search enginesA
Read-onlyIdempotent

List the available sources, grouped by what they index.

Best for:
- Choosing a source deliberately: which one indexes filings, or preprints,
  or Chinese-language pages.
- Checking a name before passing it to `engines=` on `search` / `research`.

Not recommended for:
- Calling on every search: the list is static, so read it once.

Returns (markdown): a `group -> sub-group -> engine` tree, one line of
description per engine. `group="paper"` restricts it to that group.
Returns (json): `{"engines": [...names...], "taxonomy": {...},
"descriptions": {...}}`.

Prefer `category=` over `engines=`. `category="paper"` WIDENS: it routes to
one specialist per sub-group. A dotted sub-group NARROWS: `"paper.biomed"`
queries only the biomedical indexes. Naming engines explicitly turns that
routing off entirely, so reach for it only to force a specific source.

Common mistakes:
- Passing one of these names as `query`: they belong in `engines=`.
- Passing a key-only engine with no key configured; it returns an
  actionable error, not results.

Inputs: group, format.

extract_structuredExtract structured data from a URLA
Read-onlyIdempotent

Pull JSON-LD, OpenGraph, Twitter cards, and microdata from a web page.

Best for:
- Product pages (price, currency, availability, brand, rating).
- Article pages (author, publish date, image, headline).
- Recipe / event / video pages where rich metadata IS the answer.
- Cases where `fetch` returns prose but you need fields.

Not recommended for:
- Just reading a page -> use `fetch`.
- PDFs / DOCX -> use `read_doc`.
- Pages that don't publish schema.org metadata (most blogs): you'll get
  empty lists; fall back to `fetch`.

Returns:
- json: {url, json_ld:[], microdata:[], opengraph:[], rdfa:[]}. Twitter
  card meta tags are surfaced inside the `opengraph` list.
- markdown (default): a flattened key/value view with each block printed
  as a JSON code block under its syntax heading.

Common mistakes:
- Calling on every URL "just in case": most sites have no structured
  data, and `fetch` is what you actually want.

Args:
    url: Absolute http(s) URL.
    format: "markdown" (default) or "json".

Inputs: url (required), format.

fetchFetch a URL: page text, document, or resourceA
Read-onlyIdempotent

Fetch one URL: page text, or a description of a non-text resource.

Handles any http(s) resource, not just HTML:
- HTML pages -> reader-mode Markdown (nav/footer/scripts stripped).
- PDF/DOCX/XLSX/PPTX/EPUB/CSV/code/archives -> parsed text (same engine as
  `read_doc`, which you should prefer when you need pagination).
- Images, video, audio, fonts, opaque binaries -> a description
  (media type, byte size, dimensions, sha256), NOT the bytes.

Best for:
- You already have a URL (from `search`, the user, or your own knowledge)
  and need the actual page text.
- Verifying a single claim by reading the source.
- Checking what a resource IS before deciding to spend tokens on it.

Not recommended for:
- Multiple URLs at once -> use `fetch_batch` (concurrent, one round-trip).
- "Search then read top N" -> use `research` (one call, not two).
- Long documents you need to page through -> use `read_doc` (start/length).
- You don't have a URL yet -> use `search` first.

Returns:
- markdown (default): a small header (URL, render method, token count)
  plus the cleaned page body.
- json: {url, title, content, method, truncated, tokens_estimated,
  author, published_date, sitename}, plus {media_type, bytes_size, sha256,
  width, height} for non-text resources.
- With `inline=True` on an image: the image itself, viewable by a
  vision-capable model.

Common mistakes:
- Passing a search query instead of a URL.
- Using `render="http"` on a JS-only SPA: it returns near-empty content;
  use "auto" (default) or "browser".
- Setting `inline=True` on a large image out of habit. A 1MB image costs
  well over a thousand tokens; fetch it plainly first and inline only if
  the description says it's worth looking at.
- Forgetting that results are cached 7 days: use `force_refresh=True`
  or `max_age_hours=0` for a fresh pull. The header says `cached N days ago`
  when you are not looking at the live page; for deadlines, prices and
  anything else that moves, that is the cue to refresh.
- Reading `no publication date found` as "recent". It means unknown.

Args:
    url: Absolute http(s) URL.
    render: "auto" (try HTTP, fall back to stealth Chromium), "http"
        (fast, fails on JS), "browser" (slow, robust).
    force_refresh: Bypass the page cache entirely.
    max_age_hours: Treat cached pages older than this as a miss. 0 = same
        as force_refresh. None = server default TTL (7 days).
    inline: For images only. Returns the image itself instead of a
        description, so a vision-capable model can see it. Ignored for
        text resources.
    format: "markdown" or "json".

Inputs: url (required), format, inline, render, +2 more.

fetch_batchFetch many URLs concurrentlyA
Read-onlyIdempotent

Fetch a list of URLs in parallel. Per-URL failures do not raise.

Best for:
- 2+ URLs you want to read in one round-trip.
- Reading the top N results of a previous `search` call.

Not recommended for:
- A single URL -> `fetch` (no list-wrapping overhead).
- "Search and then read" -> `research` collapses both into one tool call.
- PDFs/DOCX -> `read_doc` per file.

Returns:
- markdown (default): each page rendered as a Markdown section, separated
  by horizontal rules; failed URLs become inline error notes.
- json: list[dict], one entry per URL, with `error` set on failures.

Common mistakes:
- Passing a single URL inside a 1-element list: use `fetch` directly.
- Assuming an exception means the whole batch failed; check each item's
  `error` field instead.

Args:
    urls: List of absolute http(s) URLs (max 20 per call).
    render: Same as `fetch`.
    format: "markdown" or "json".

Inputs: urls (required), format, render.

paper_graphWalk a paper's citation graphA
Read-onlyIdempotent

Follow the citations of ONE paper, and check whether it still stands.

`search` finds papers that MENTION your words. This follows the edges
instead: what a specific paper built on, and what has built on it since.

Best for:
- Checking a citation before repeating it: is the DOI real, and has the
  paper been retracted or corrected?
- "What happened after this result": citing works come back ordered by how
  much the field cited them, so a 2019 paper leads to the current state of
  the art rather than to the most recent preprint about it.
- Building a reading list backwards from one good paper.

Not recommended for:
- Finding papers by topic -> `search(category="paper")`, or a sub-group
  like `"paper.biomed"` / `"paper.cs"` / `"paper.preprint"`.
- Reading the paper itself -> `read_doc` on the returned URL.

Returns:
- markdown (default): the paper with its retraction/correction notices,
  then "References" and "Cited by" sections.
- json: {paper, references, citations, notes}, where `paper.crossref`
  carries `registered` and every post-publication `notices` entry.

Common mistakes:
- Passing a topic instead of a paper. A title resolves to its single best
  match; a phrase that names no specific paper resolves to the wrong one.
- Reading an empty `citations` list as "uncited" when `notes` says the
  lookup was truncated.

Args:
    paper: DOI (`10.1145/1571941.1572114`, or a doi.org URL), an OpenAlex
        ID (`W2148972377`), or the paper's exact title.
    direction: "both", "references" (what it cites) or "citations" (what
        cites it).
    limit: Max neighbours per direction, 1-50.
    format: "markdown" or "json".

Inputs: paper (required), limit, format, direction.

read_docRead a remote (or sandboxed local) documentA
Read-onlyIdempotent

Read an http(s) document (or a sandboxed local file) into Markdown.

Best for:
- Remote PDFs and DOCX from an http(s) URL (parsed locally, no remote API).
- Local PDF/DOCX/text/Markdown files, ONLY when local reads are enabled
  (see Security below).
- Paginating through a long document via `start` / `length`.

Not recommended for:
- Arbitrary HTML web pages -> `fetch` does reader-mode cleanup that this
  tool does not.
- Pages discovered through search -> `fetch` or `research`.

Security (local files are sandboxed and OFF by default):
- Local-file reads are DISABLED unless the server operator sets the
  SEARCH_MCP_DOCUMENT_ROOT env var to a directory. With it unset, a local
  path raises a "local file reads are disabled" error. Pass an http(s)
  URL instead, or ask the operator to enable the sandbox.
- When enabled, `source` must resolve INSIDE that root; relative paths
  resolve against the root (not the process CWD) and any `..` traversal
  that escapes the root is rejected. `file://` URLs are always rejected.
- Remote http(s) sources are unaffected by this setting.

Returns:
- markdown (default): rendered document text with a small header.
- json: {content, title, format, total_chars, start, returned_chars,
  truncated}. Use `total_chars` and `returned_chars` to drive pagination.

Common mistakes:
- Calling this on a normal article URL: you'll get raw HTML noise. Use
  `fetch` instead.
- Forgetting to advance `start` when paginating: next call should pass
  `start = previous_start + returned_chars`.
- Passing a negative `length` (raises an error) or a `start` past the end
  (clamped to EOF: you'll get `returned_chars == 0`, `start == total_chars`,
  and `truncated == False`, which is the signal you've paged off the end).

Args:
    source: http(s) URL, or a local path UNDER SEARCH_MCP_DOCUMENT_ROOT when
        local reads are enabled (disabled by default; see Security).
    start: Character offset to begin reading from. Default 0. Clamped into
        [0, total_chars]; a negative value is treated as 0.
    length: Max characters to return; None = read to end (still capped by
        the per-call max content size). Must be >= 0. A negative length
        is rejected with a ValueError.
    format: "markdown" or "json".

Inputs: source (required), start, format, length.

researchSearch and read in one callA
Read-only

One-shot research: search the web, fetch the top results, return both.

Best for:
- Open-ended questions that need finding sources AND reading them
  ("what's new with X", "summarize the controversy around Y").
- Replacing a `search` + N x `fetch` chain with one call.
- Producing a citable brief with [n]-style source references.

Not recommended for:
- You only need links -> `search` (cheaper, no fetching).
- You only need to read one URL you already have -> `fetch`.
- You want to query previously-fetched cached pages -> `cache_search`.
- Checking or expanding one paper's citations -> `paper_graph`.

Returns:
- markdown (default): a "Research brief" with a Sources index then the
  full Markdown body of each fetched document, separated by horizontal
  rules; includes a token estimate.
- json: {question, engines, sources:[{rank,title,url,snippet,...}],
  documents:[...], tokens_estimated, errors}.

Common mistakes:
- Using `depth=8` for a quick lookup: that's 8 page fetches, and 2-3 is
  almost always enough.
- Calling `research` for a known URL: that is what `fetch` is for.
- Forgetting that `fetch=False` returns sources only (much cheaper if
  the LLM only needs to pick which one to read).

Args:
    question: What you want to know, in natural language.
    depth: How many top results to fetch (1-8). 3 is a good default.
    engines: Override the engine set (see `engines()` for names). Prefer
        `category=`. Naming engines turns category routing off.
    fetch: If False, return source list without reading them.
    freshness: "day"|"week"|"month"|"year". Restricts to recent results.
        Best-effort; undated results are kept rather than dropped.
    include_domains: Restrict to these domains (e.g. ["python.org"]).
    exclude_domains: Drop results from these domains.
    category: Which KIND of source to search; a bare group widens, a dotted
        sub-group narrows. Same values as `search`; see `engines()`.
    include_text: Substring required in title or snippet (case-insensitive).
    exclude_text: Substring forbidden in title or snippet.
    use_cache: Reuse cached search/page data within TTL.
    max_age_hours: Treat cached search results AND cached page bodies older
        than this as a read miss; fresh data is always written back. 0 =
        force-refresh both the engine search and every fetched page body;
        None = server default TTL (7 days). A non-zero value is honored for
        both halves (it used to be ignored for anything but 0).
    format: "markdown" or "json".

Inputs: question (required), depth, fetch, format, +9 more.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A4.8/5.0

    Scored across 11 tools

    Disambiguation5/5

    Each tool has a sharply bounded purpose, and the descriptions actively preempt confusion with explicit 'Not recommended for' cross-references (fetch vs fetch_batch vs compare vs research, read_doc vs fetch on documents, search vs cache_search). The one genuinely thin boundary — compare vs fetch_batch for multi-URL reads — is spelled out by URL-count and output-shape rules.

    Naming Consistency4/5

    All names are lowercase snake_case with a consistent style, and most follow verb_noun or verb_object (fetch_batch, cache_search, read_doc, extract_structured). A few are bare verbs or nouns (search, fetch, compare, download, engines, research) and paper_graph is noun_noun, but the set still reads predictably.

    Tool Count5/5

    Eleven tools is squarely in the sweet spot for a search-and-retrieval server. Every tool maps to a distinct workflow primitive (discover, read, batch, compare, extract, cache, cite, save) with no filler.

    Completeness5/5

    The surface covers the full lifecycle: discovery (search/research/engines), retrieval (fetch/fetch_batch/read_doc with pagination), inspection (extract_structured), local corpus reuse (cache_search), citation tracing (paper_graph), and file persistence (download). Only very minor cache-management gaps exist (no listing or eviction of cached pages), which agents can work around.

    Maintenance

    ActivityActive
    ResponsivenessOutdated data

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      D
      maintenance
      A lightweight MCP server that enables LLMs to search the web via DuckDuckGo, search GitHub code repositories, and extract clean content from web pages in LLM-friendly formats.
      9
      MIT
    • A
      license
      Not graded
      quality
      B
      maintenance
      A zero-config web search and fetch MCP server for LLM agents, featuring multi-backend metasearch, persistent rolling cache, and structured error envelopes for retry-friendly interactions.
      MIT
    • A
      license
      Not graded
      quality
      F
      maintenance
      MCP server enabling local-first web search, fetch, extract, and caching with citeable excerpts, no API key required. Supports research workflows for agents and apps.
      67 npm
      1
      MIT