# Web search MCP server voor Claude Code, Claude Desktop, Cursor en andere MCP-clients

> Web search MCP server voor Claude Code, Claude Desktop en Cursor: een kort Python-bestand met de tools search_web en read_urls, geregistreerd met één commando.

- URL: https://llmwebsearch.com/nl/docs/mcp/
- Laatst bijgewerkt: 2026-10-22
- Uitgever: LLMWebSearch (https://llmwebsearch.com)

Geef elke MCP-client twee tools: `search_web`, dat gerangschikte bronnen teruggeeft met de bovenste pagina's al gelezen, en `read_urls`, dat links leest die het model al heeft. De server is één Python-bestand dat op je machine draait, met je API-sleutel in zijn environment.

**Snel antwoord — Hoe voeg ik een web search MCP server toe aan Claude Code of Claude Desktop?**

Sla de korte Python-server op deze pagina op, die de tools `search_web` en `read_urls` aanbiedt die **LLMWebSearch** aanroepen, en registreer hem dan met `claude mcp add` of in `claude_desktop_config.json`, met je API-sleutel in `env`. Het model kan dan het live web doorzoeken en de bovenste pagina's als Markdown lezen. Een zoekopdracht kost 1 credit, vanaf US$ 1,20/1K zoekopdrachten per oktober 2026. Zonder KYC; betalen met crypto.

## De MCP-server in één oogopslag

| Attribuut | Waarde |
| --- | --- |
| Taal | Python 3.10+, met de packages `mcp` en `httpx` |
| Transport | stdio: de client start de server als lokaal proces |
| Tool 1 | `search_web(query, max_results=5, read=3)` → genummerde bronnen met URL's en paginatekst |
| Tool 2 | `read_urls(urls)` → de hoofdinhoud van 1 tot 20 bekende pagina's |
| Namen | Niet `web_search` of `web_fetch`: Claude Code en OpenClaw leveren al tools met die namen |
| Sleutel | Lees uit `LLMWEBSEARCH_API_KEY` in de environment van de server |
| Facturering | Eén credit betaalt één zoekopdracht: tot 20 gerangschikte resultaten, waarbij de pagina's van de eerste 3 worden gelezen en als Markdown teruggegeven. Het lezen van 4 tot 10 pagina's kost 2 credits. Een call die op een fout eindigt, kost niets. Het lezen van pagina's waarvan je de URL's al hebt, kost 1 credit per begonnen groep van 3 pagina's die met inhoud worden teruggegeven, tot 20 URL's per call; geweigerde of mislukte URL's tellen niet mee |

## Waarom heten de tools search_web en read_urls?

Omdat twee tools met dezelfde naam de client en het model in de war brengen. Claude Code en OpenClaw bevatten elk ingebouwde tools met de naam `web_search` en `web_fetch`. Aparte namen, met duidelijke beschrijvingen, laten het model bewust voor de onze kiezen en laten jou de calls in logs uit elkaar houden.

Beide tools geven tekst terug, geen ruwe JSON. Elke bron begint met een nummer, een titel en de URL, zodat het model `[1]` of `[2]` kan citeren en de lezer de pagina kan controleren.

*llmwebsearch_mcp.py*

```python
import os

import httpx
from mcp.server.fastmcp import FastMCP

BASE = "https://llmwebsearch.com/api/v1"
HEADERS = {"Authorization": "Bearer " + os.environ["LLMWEBSEARCH_API_KEY"]}
mcp = FastMCP("llmwebsearch")


def _call(path: str, body: dict) -> dict:
    resp = httpx.post(BASE + path, json=body, headers=HEADERS, timeout=90)
    data = resp.json()
    if resp.status_code != 200:
        err = data.get("error", {})
        raise RuntimeError(err.get("code", str(resp.status_code)) + ": " + err.get("message", ""))
    return data


def _page(n: int, item: dict) -> str:
    head = f"[{n}] {item.get('title') or item['url']}\n{item['url']}\n"
    if item.get("content_status") == "ok":
        return head + item["content"]
    return head + "(not read: " + item.get("content_status", "unknown") + ") " + item.get("snippet", "")


@mcp.tool()
def search_web(query: str, max_results: int = 5, read: int = 3) -> str:
    """Search the live web and return numbered sources; the first `read` pages include their text.

    Use it for current facts, documentation and news. Cite sources by their number.
    """
    body = {"q": query, "max_results": max(1, min(max_results, 20)), "read": max(0, min(read, 10)), "max_chars": 5000}
    data = _call("/search", body)
    return "\n\n".join(_page(i, r) for i, r in enumerate(data["results"], start=1))


@mcp.tool()
def read_urls(urls: list[str]) -> str:
    """Read 1 to 20 public web pages whose URLs you already have and return their main text."""
    data = _call("/extract", {"urls": urls[:20], "max_chars": 12000})
    return "\n\n".join(_page(i, r) for i, r in enumerate(data["results"], start=1))


if __name__ == "__main__":
    mcp.run()

```

## Hoe installeer en test ik de server?

Maak een virtual environment, installeer `mcp` en `httpx` en sla het bestand hierboven op. `mcp` is de officiële Python SDK van het Model Context Protocol; de klasse `FastMCP` maakt van getypeerde Python-functies tools en gebruikt elke docstring als beschrijving van de tool.

Start het bestand één keer vanuit een terminal met je API-sleutel ingesteld. Het wacht dan rustig op een client op standard input, wat betekent dat het werkt; stop het met Ctrl+C. Fouten van de API worden als tool-fouten met hun code opgeworpen, zodat het model `rate_limited` of `insufficient_credits` in gewone woorden ziet.

*Installeren en één keer starten*

```bash
python -m venv .venv
. .venv/bin/activate
pip install "mcp[cli]" httpx
LLMWEBSEARCH_API_KEY="your-key" python llmwebsearch_mcp.py
```

## Hoe voeg ik het toe aan Claude Code?

Gebruik `claude mcp add`. De documentatie van Claude Code geeft de vorm `claude mcp add [options] <name> -- <command> [args...]`: eerst de eigen opties, dan een dubbele streep, dan het commando dat de server start. Environment-variabelen gaan in `--env KEY=value`, en minstens één andere optie, zoals `--transport stdio`, moet tussen `--env` en de servernaam staan.

Voeg `--scope user` toe om de server in al je projecten beschikbaar te maken; de standaardscope, `local`, dekt alleen het huidige project. Gebruik absolute paden voor de Python van je virtual environment en voor het serverbestand.

*Registreer de server in Claude Code*

```bash
claude mcp add --env LLMWEBSEARCH_API_KEY=your-key --transport stdio --scope user llmwebsearch \
  -- /home/you/llmwebsearch/.venv/bin/python /home/you/llmwebsearch/llmwebsearch_mcp.py
```

## Hoe voeg ik het toe aan Claude Desktop en andere clients?

Claude Desktop leest servers uit `claude_desktop_config.json`, onder `mcpServers`. Geef de server een naam, het commando, de argumenten en een `env`-object met de sleutel, en herstart daarna de app; `search_web` en `read_urls` verschijnen in de lijst met tools.

Andere MCP-clients, zoals Cursor, vragen dezelfde drie dingen in hun eigen MCP-instellingen: een commando, de argumenten en environment variables. De sleutel verschijnt nooit in een tool-argument of in het gesprek.

*claude_desktop_config.json*

```json
{
  "mcpServers": {
    "llmwebsearch": {
      "command": "/home/you/llmwebsearch/.venv/bin/python",
      "args": ["/home/you/llmwebsearch/llmwebsearch_mcp.py"],
      "env": { "LLMWEBSEARCH_API_KEY": "your-key" }
    }
  }
}
```

## Hoe houd ik zoekopdrachten goedkoop en kort?

Vertel het model in je instructies hoe het moet zoeken: één of twee zoekopdrachten per vraag, en lees daarna alleen verder als de bronnen het oneens zijn. De server begrenst elke pagina al tot 5.000 tekens in `search_web` en 12.000 in `read_urls`; verlaag die getallen voor kleine modellen.

Elke `search_web`-aanroep met `read` tot 3 is één credit. Een assistant die 40 zoekopdrachten per dag doet, gebruikt ongeveer 1.200 credits per maand, dus 5.000 zoekopdrachten (US$ 9,25) gaat ongeveer vier maanden mee. Zoekcredits verlopen niet: wat je deze maand niet gebruikt, staat er volgend jaar nog.

## Wat ziet het model als een pagina niet gelezen kan worden?

De bron verschijnt nog steeds, met het nummer, de titel en de URL, gevolgd door de reden tussen haakjes en het zoekfragment. Onze reader respecteert robots.txt: hij stelt zich voor als LLMWebSearch, volgt de regels die een site voor hem of voor alle robots schrijft, en laat de inhoud weg van elke pagina die hij niet mag lezen. Wanneer een site onze reader weert, komt het resultaat terug zonder inhoud en met de status van de site: we lossen nooit CAPTCHA's op, loggen nooit in op accounts en werken nooit om een blokkade of een paywall heen. Het model kan dan op de andere bronnen vertrouwen of zeggen dat één pagina niet beschikbaar was.

## MCP-server: veelgestelde vragen

### Is er een officieel LLMWebSearch MCP-pakket of gehost endpoint?

Nee. Het bestand op deze pagina is de integratie: ongeveer 50 regels die je kunt lezen en aanpassen. Het draait op je eigen machine, en je sleutel gaat alleen naar onze API.

### Moet ik de ingebouwde webzoekfunctie van Claude Code uitzetten?

Niet nodig. Beide kunnen blijven; de beschrijvingen vertellen het model wat elk doet. Houd de onze aan als je paginatekst in de resultaten wilt, een vaste prijs per zoekopdracht, of één plek voor je zoeklogs.

### Kan ik het met OpenClaw gebruiken?

Ja, als een MCP-server die je registreert met `openclaw mcp add`. De [OpenClaw-pagina](https://llmwebsearch.com/nl/docs/openclaw/) geeft het commando en legt uit hoe het naast OpenClaw's ingebouwde zoekproviders zit.

### Bewaart de server mijn zoekopdrachten?

Nee. Hij bewaart niets tussen aanroepen. Aan onze kant, We trainen geen enkel model op je zoekopdrachten of op wat de API teruggeeft, en we voegen geen eigen regel toe tegen het opslaan van resultaten; de rechten van de sites waarvan je pagina's leest, gelden nog steeds.

## Bronnen

1. [Claude Code verbinden met tools via MCP](https://code.claude.com/docs/en/mcp) — Claude Code docs (read 2026-10-22)

---

LLMWebSearch: LLMWebSearch is een webzoek-API voor AI-agents die gerangschikte resultaten teruggeeft met de inhoud van de belangrijkste pagina's als Markdown, betaald met crypto zonder ID-upload. Voorafbetaalde credits vanaf US$ 1,20/1K zoekopdrachten verlopen nooit. Zonder KYC — geen ID, geen selfie, geen documenten. Betalen met crypto.
