# Web-Such-MCP-Server für Claude Code, Claude Desktop, Cursor und andere MCP-Clients

> Web-Such-MCP-Server für Claude Code, Claude Desktop und Cursor: kurze Python-Datei mit search_web und read_urls, per Befehl registriert. Ohne KYC.

- URL: https://llmwebsearch.com/de/docs/mcp/
- Zuletzt aktualisiert: 2026-10-22
- Herausgeber: LLMWebSearch (https://llmwebsearch.com)

Geben Sie jedem MCP-Client zwei Tools: `search_web`, das gerankte Quellen mit bereits gelesenen Top-Seiten liefert, und `read_urls`, das Links liest, die das Modell bereits hat. Der Server ist eine einzige Python-Datei, die auf Ihrem Rechner läuft, mit Ihrem Schlüssel in seiner Umgebung.

**Kurze Antwort — Wie füge ich einen Web-Such-MCP-Server zu Claude Code oder Claude Desktop hinzu?**

Speichern Sie den kurzen Python-Server von dieser Seite, der die Tools `search_web` und `read_urls` bereitstellt, die **LLMWebSearch** aufrufen, und registrieren Sie ihn dann mit `claude mcp add` oder in `claude_desktop_config.json`, mit Ihrem Schlüssel in `env`. Das Modell kann dann das Live-Web durchsuchen und die Top-Seiten als Markdown lesen. Eine Suchanfrage kostet 1 Credit, ab 1,20 $/1K Suchanfragen Stand Oktober 2026. Ohne KYC; mit Krypto bezahlen.

## Der MCP-Server auf einen Blick

| Attribut | Wert |
| --- | --- |
| Sprache | Python 3.10+, mit den Paketen `mcp` und `httpx` |
| Transport | stdio: der Client startet den Server als lokalen Prozess |
| Tool 1 | `search_web(query, max_results=5, read=3)` → nummerierte Quellen mit URLs und Seitentext |
| Tool 2 | `read_urls(urls)` → der Hauptinhalt von 1 bis 20 bekannten Seiten |
| Namen | Nicht `web_search` oder `web_fetch`: Claude Code und OpenClaw liefern bereits Tools mit diesen Namen aus |
| API-Schlüssel | Lesen Sie aus `LLMWEBSEARCH_API_KEY` in der Umgebung des Servers |
| Abrechnung | Ein Credit bezahlt eine Suchanfrage: bis zu 20 gerankte Ergebnisse, wobei die Seiten der ersten 3 gelesen und als Markdown zurückgegeben werden. Werden 4 bis 10 Seiten gelesen, sind es 2 Credits. Ein Aufruf, der mit einem Fehler endet, kostet nichts. Das Lesen von Seiten, deren URLs Sie bereits haben, kostet 1 Credit für jede angefangene Gruppe von 3 Seiten, die mit Inhalt zurückgegeben werden, bis zu 20 URLs pro Aufruf; abgelehnte oder fehlgeschlagene URLs werden nicht gezählt |

## Warum heißen die Tools search_web und read_urls?

Weil zwei Tools mit demselben Namen den Client und das Modell verwirren. Claude Code und OpenClaw enthalten jeweils integrierte Tools namens `web_search` und `web_fetch`. Eindeutige Namen mit klaren Beschreibungen lassen das Modell gezielt unser Tool wählen und Sie die Aufrufe in Logs auseinanderhalten.

Beide Tools geben Text zurück, kein rohes JSON. Jede Quelle beginnt mit einer Nummer, einem Titel und ihrer URL, sodass das Modell `[1]` oder `[2]` zitieren kann und der Leser die Seite prüfen kann.

*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()

```

## Wie installiere und teste ich den Server?

Erstellen Sie eine virtuelle Umgebung, installieren Sie `mcp` und `httpx` und speichern Sie die obige Datei. `mcp` ist das offizielle Python SDK des Model Context Protocol; seine Klasse `FastMCP` macht aus typisierten Python-Funktionen Tools und verwendet jeden Docstring als Beschreibung des Tools.

Starten Sie die Datei einmal aus einem Terminal mit gesetztem Schlüssel. Sie wartet dann still auf einen Client an der Standardeingabe, was bedeutet, dass sie funktioniert; beenden Sie sie mit Ctrl+C. Fehler der API werden als Tool-Fehler mit ihrem Code ausgegeben, sodass das Modell `rate_limited` oder `insufficient_credits` im Klartext sieht.

*Installieren und einmal starten*

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

## Wie füge ich es zu Claude Code hinzu?

Verwenden Sie `claude mcp add`. Die Dokumentation von Claude Code gibt die Form `claude mcp add [options] <name> -- <command> [args...]` an: zuerst kommen die eigenen Optionen, dann ein doppelter Bindestrich, dann der Befehl, der den Server startet. Umgebungsvariablen kommen in `--env KEY=value`, und mindestens eine weitere Option, etwa `--transport stdio`, muss zwischen `--env` und dem Servernamen stehen.

Fügen Sie `--scope user` hinzu, damit der Server in allen Ihren Projekten verfügbar ist; der Standard-Scope `local` deckt nur das aktuelle Projekt ab. Verwenden Sie absolute Pfade für das Python Ihrer virtuellen Umgebung und für die Serverdatei.

*Den Server in Claude Code registrieren*

```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
```

## Wie füge ich es zu Claude Desktop und anderen Clients hinzu?

Claude Desktop liest Server aus `claude_desktop_config.json`, unter `mcpServers`. Geben Sie dem Server einen Namen, den Befehl, seine Argumente und ein `env`-Objekt mit dem Schlüssel, und starten Sie dann die App neu; `search_web` und `read_urls` erscheinen in der Werkzeugliste.

Andere MCP-Clients wie Cursor fragen in ihren eigenen MCP-Einstellungen dieselben drei Dinge ab: einen Befehl, seine Argumente und Umgebungsvariablen. Der Schlüssel erscheint nie in einem Werkzeug-Argument oder im Gespräch.

*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" }
    }
  }
}
```

## Wie halte ich Suchanfragen günstig und kurz?

Sagen Sie dem Modell in Ihren Anweisungen, wie es suchen soll: eine oder zwei Suchanfragen pro Frage, dann nur weiterlesen, wenn die Quellen voneinander abweichen. Der Server begrenzt jede Seite bereits auf 5.000 Zeichen in `search_web` und 12.000 in `read_urls`; senken Sie diese Zahlen für kleine Modelle.

Jeder `search_web`-Aufruf mit `read` bis 3 ist ein Credit. Ein Assistent, der 40 Suchanfragen pro Tag ausführt, verbraucht etwa 1.200 Credits pro Monat, sodass 5.000 Suchanfragen (9,25 $) rund vier Monate reicht. Search-Credits verfallen nicht: Was Sie diesen Monat nicht verbrauchen, ist nächstes Jahr noch da.

## Was sieht das Modell, wenn eine Seite nicht gelesen werden kann?

Die Quelle erscheint trotzdem, mit ihrer Nummer, ihrem Titel und ihrer URL, gefolgt vom Grund in Klammern und dem Such-Snippet. Unser Reader respektiert robots.txt: Er stellt sich als LLMWebSearch vor, befolgt die Regeln, die eine Website für ihn oder für alle Roboter schreibt, und lässt den Inhalt jeder Seite aus, die er nicht lesen darf. Wenn eine Website unseren Reader abweist, kommt das Ergebnis ohne Inhalt und mit dem Status der Website zurück: Wir lösen niemals CAPTCHAs, melden uns nicht in Konten an und umgehen weder eine Sperre noch eine Paywall. Das Modell kann sich dann auf die anderen Quellen verlassen oder sagen, dass eine Seite nicht verfügbar war.

## MCP-Server: häufige Fragen

### Gibt es ein offizielles LLMWebSearch-MCP-Paket oder einen gehosteten endpoint?

Nein. Die Datei auf dieser Seite ist die Integration: etwa 50 Zeilen, die Sie lesen und ändern können. Sie läuft auf Ihrem Rechner, und Ihr Schlüssel geht nur an unsere API.

### Sollte ich die integrierte Websuche von Claude Code abschalten?

Nicht nötig. Beide können bleiben; die Beschreibungen sagen dem Modell, was jede tut. Behalten Sie unsere, wenn Sie Seitentext in den Ergebnissen, einen festen Preis pro Suchanfrage oder einen zentralen Ort für Ihre Such-Logs möchten.

### Kann ich es mit OpenClaw verwenden?

Ja, als MCP-Server, der mit `openclaw mcp add` registriert wird. Die [OpenClaw-Seite](https://llmwebsearch.com/de/docs/openclaw/) gibt den Befehl und erklärt, wie er neben den integrierten Suchanbietern von OpenClaw funktioniert.

### Speichert der Server meine Suchanfragen?

Nein. Er hält zwischen Aufrufen nichts. Auf unserer Seite: Wir trainieren kein Modell mit Ihren Suchanfragen oder mit dem, was die API zurückgibt, und wir stellen keine eigene Regel gegen das Speichern von Ergebnissen auf; die Rechte der Websites, deren Seiten Sie lesen, gelten weiterhin.

## Quellen

1. [Claude Code über MCP mit Tools verbinden](https://code.claude.com/docs/en/mcp) — Claude Code docs (read 2026-10-22)

---

LLMWebSearch: LLMWebSearch ist eine Websuch-API für KI-Agenten, die gerankte Ergebnisse mit dem Inhalt der Top-Seiten als Markdown liefert, bezahlt mit Krypto ohne Ausweis-Upload. Vorausbezahlte Credits ab 1,20 $/1K Suchanfragen verfallen nie. Ohne KYC — kein Ausweis, kein Selfie, keine Dokumente. Mit Krypto bezahlen.
