# BlockVectra-MCP-Server: Blockchain-RPC- und Dokumentations-Tools für KI-Agenten

> Source: https://docs.blockvectra.com/de/guides/mcp-server/

Der BlockVectra-MCP-Server unter `https://docs.blockvectra.com/mcp` stellt Entwicklern und KI-Agenten 15 Tools für Blockchain-RPC-Aufrufe, Chain-Status, Preise und Dokumentation bereit. Für die Verbindung ist kein API key nötig: 10 Tools brauchen nie einen; die übrigen verwenden `x-api-key` aus den Headern Ihres Clients. Installation in einer Zeile: `claude mcp add --transport http blockvectra-docs https://docs.blockvectra.com/mcp`

Der Endpunkt ist der [MCP-Endpunkt](https://docs.blockvectra.com/mcp) (HTTP POST nimmt JSON-RPC 2.0 entgegen; GET liefert 405), bereitgestellt über MCP Streamable HTTP und zustandslos. Zu den HTTP-Dateien, dem öffentlichen JSON und dem zugehörigen Registrierungsablauf siehe [KI-Agenten verbinden](https://docs.blockvectra.com/de/guides/ai-agents/).

## Tools

| Tool | Was es tut | API key | Zugriff |
| --- | --- | --- | --- |
| `read_doc` | Liest eine Dokumentationsseite als Markdown. | Nicht erforderlich | Nur lesend |
| `search_docs` | Durchsucht Titel, Pfade und Zusammenfassungen der Dokumentation. | Nicht erforderlich | Nur lesend |
| `list_chains` | Listet unterstützte Chains, Parameter und Methodenrichtlinien auf (GET /v1/chains). | Nicht erforderlich | Nur lesend |
| `get_status` | Liest den Live-Status von Dienst und Chains (GET /v1/status). | Nicht erforderlich | Nur lesend |
| `get_pricing` | Liest Compute-Unit-Gewichte, Free-Plan-Parameter und Key-Standardwerte (GET /v1/plans). | Nicht erforderlich | Nur lesend |
| `estimate_usage` | Schätzt Compute Units und Kosten für eine oder mehrere Methoden. | Nicht erforderlich | Nur lesend |
| `how_to_get_api_key` | Liefert die Schritte zum Erhalt eines API key und die Formen der Anfrage-Authentifizierung. | Nicht erforderlich | Nur lesend |
| `get_method_info` | Zeigt Verfügbarkeit einer Methode je Chain, CU-Gewicht und Preis. | Nicht erforderlich | Nur lesend |
| `explain_error` | Schlägt Bedeutung, Abrechnung, Wiederholbarkeit und Behebung eines Fehlers nach. | Nicht erforderlich | Nur lesend |
| `list_docs` | Listet jede Dokumentationsseite mit Pfad und Titel auf. | Nicht erforderlich | Nur lesend |
| `rpc_call` | Führt eine schreibgeschützte JSON-RPC-Methode auf einer unterstützten Chain aus. | Optional: ohne Key nur für Methoden in public.methods der Chain | Nur lesend |
| `data_api_get` | Sendet eine GET-Anfrage an die Data API einer unterstützten Chain. | Erforderlich (Header x-api-key) | Nur lesend |
| `get_account` | Liest Kontoguthaben, CU und Ratenlimits (GET /v1/account). | Erforderlich (Header x-api-key) | Nur lesend |
| `get_deposit_address` | Liest die Einzahlungsadresse des Kontos sowie offene Netzwerke und Token. | Erforderlich (Header x-api-key) | Nur lesend |
| `send_raw_transaction` | Sendet eine bereits signierte Roh-Transaktion (eth_sendRawTransaction). | Optional: ohne Key nur für Methoden in public.methods der Chain | Sendet eine signierte Transaktion |

Diese Tabelle wird aus dem Tool-Register des Servers erzeugt und listet daher jedes Tool auf, das `tools/list` zurückgibt. Jedes Tool nimmt die Argumente entgegen und liefert die Felder, die in seinem eigenen `tools/list`-Schema beschrieben sind.

### Sicherheit des API key

Tools mit Key-Pflicht benötigen einen API key, um Data-API-Anfragen, Kontoaktionen oder RPC-Methoden außerhalb der öffentlichen Methoden einer Chain auszuführen.

* **Nur aus Headern gelesen**: Der API key wird ausschließlich aus den HTTP-Request-Headern des MCP-Clients gelesen (`x-api-key: rgw_...` oder `Authorization: Bearer rgw_...`).
* **Keys nie in den Chat**: Übergeben Sie API keys oder private Schlüssel nie in Tool-Argumenten und fügen Sie sie nicht in den Chat ein. Tool-Argumente und Chatverlauf gelangen in Konversationsprotokolle und Kontexte; Keys in Argumenten werden abgelehnt.

Wenn sie ohne API-key-Header aufgerufen werden, liefern Tools mit Key-Pflicht `isError: true` und verweisen den Agenten auf `how_to_get_api_key` und den [Leitfaden zur programmatischen Registrierung](https://docs.blockvectra.com/de/guides/programmatic-signup/?ref=docs-mcp-server).

## Im eigenen Client installieren

Sie können den BlockVectra-Dokumentations-MCP-Server unter `https://docs.blockvectra.com/mcp` in gängigen Entwicklungsumgebungen und Frameworks anbinden.

Beginnen Sie ohne API key. Verbinden Sie sich mit dem MCP-Endpunkt, rufen Sie list\_chains auf und lesen Sie dann quickstart mit read\_doc. Tragen Sie einen API key in die HTTP-Header Ihres Clients ein, wenn Sie Data-API- oder Konto-Tools benötigen. Der schlüssellose RPC-Zugriff folgt der Richtlinie für öffentliche Methoden der jeweiligen Chain.

Der Header `x-api-key` ist optional. Ohne API key können Clients alle schreibgeschützten Dokumentations-Tools (`read_doc`, `search_docs`, `list_docs`), die Chain-Erkennung (`list_chains`), den Live-Status (`get_status`), die Preisschätzung (`get_pricing`, `estimate_usage`), Fehlererklärungen (`explain_error`) und die an öffentlichen Endpunkten erlaubten Methoden nutzen. Für Tools mit Key-Pflicht (`rpc_call` bei eingeschränkten Methoden, `send_raw_transaction`, `data_api_get`, `get_account` und `get_deposit_address`) konfigurieren Sie den Header `x-api-key` mit Ihrem API key.

### Claude Code

Verbinden Sie sich über die CLI mit dem MCP-Server:

```bash
claude mcp add --transport http blockvectra-docs https://docs.blockvectra.com/mcp
```

Um für authentifizierte Tools einen optionalen API key mitzugeben, übergeben Sie die Option `--header` (oder `-H`) und verweisen Sie auf eine Umgebungsvariable, statt den Key einzufügen. Verwenden Sie einfache Anführungszeichen, damit Ihre Shell sie nicht expandiert; Claude Code expandiert `${BLOCKVECTRA_API_KEY}` beim Start der Sitzung:

```bash
claude mcp add --transport http blockvectra-docs https://docs.blockvectra.com/mcp \
  --header 'x-api-key: ${BLOCKVECTRA_API_KEY}'
```

Dieselbe Konfiguration als `.mcp.json` auf Projektebene (das schreibt auch `claude mcp add --scope project`):

```json
{
  "mcpServers": {
    "blockvectra-docs": {
      "type": "http",
      "url": "https://docs.blockvectra.com/mcp",
      "headers": { "x-api-key": "${BLOCKVECTRA_API_KEY}" }
    }
  }
}
```

Exportieren Sie `BLOCKVECTRA_API_KEY` in der Umgebung, die `claude` startet. Claude Code bittet Sie, einen Server aus einer `.mcp.json` auf Projektebene beim ersten Start von `claude` in diesem Verzeichnis zu bestätigen; bis dahin zeigt `claude mcp list` ihn als `Pending approval` an.

Übergeben Sie für Skripte und CI die Datei mit `--mcp-config` und erlauben Sie die Tools des Servers. Der Key bleibt in der Umgebung und der MCP-Client setzt den Header selbst, sodass der Agent keinen Shell-Befehl braucht, der `$BLOCKVECTRA_API_KEY` expandiert (die Berechtigungsprüfung von Claude Code lehnte solche Befehle im nicht interaktiven Modus mit `Contains simple_expansion` ab):

```bash
claude -p "Use rpc_call to run eth_blockNumber on base_mainnet" \
  --mcp-config ./mcp.json --allowedTools "mcp__blockvectra-docs__*"
```

Bei gesetztem Key enthält das Ergebnis von `rpc_call` zusätzlich `cu_charged` und `balance_units`; ein schlüsselloser Aufruf liefert nur die JSON-RPC-Antwort. Ist die Variable nicht gesetzt, sendet der Client den Header-Text wörtlich und der Server antwortet mit `invalid_api_key` (Fehlercode `-32024`), statt auf den schlüssellosen Endpunkt zurückzufallen.

Offizielle Dokumentation: [Claude-Code-MCP-Dokumentation](https://code.claude.com/docs/en/mcp).

### Cursor

Fügen Sie den Server der MCP-Konfiguration von Cursor hinzu:

```json
{
  "mcpServers": {
    "blockvectra": {
      "url": "https://docs.blockvectra.com/mcp"
    }
  }
}
```

Cursor unterstützt außerdem die Ein-Klick-Installation über Deep Links mit der Base64-kodierten Konfiguration `eyJ1cmwiOiJodHRwczovL2RvY3MuYmxvY2t2ZWN0cmEuY29tL21jcCJ9` (entspricht `{"url":"https://docs.blockvectra.com/mcp"}`):

```text
cursor://anysphere.cursor-deeplink/mcp/install?name=blockvectra&config=eyJ1cmwiOiJodHRwczovL2RvY3MuYmxvY2t2ZWN0cmEuY29tL21jcCJ9
```

Wenn Sie authentifizierte Tools benötigen (Data API oder Kontoverwaltung), fügen Sie das Objekt `headers` mit Ihrem API key hinzu:

```json
{
  "mcpServers": {
    "blockvectra": {
      "url": "https://docs.blockvectra.com/mcp",
      "headers": {
        "x-api-key": "${env:BLOCKVECTRA_API_KEY}"
      }
    }
  }
}
```

Die Form `${env:NAME}` folgt der Cursor-Dokumentation, die Variablen in `url` und `headers` auflöst; diese Form wurde hier nicht gegen Cursor ausgeführt. Legen Sie die Datei in `.cursor/mcp.json` (Projekt) oder `~/.cursor/mcp.json` (global) ab.

Offizielle Dokumentation: [Cursor-MCP-Dokumentation](https://cursor.com/docs/context/mcp) und [Cursor-Installationslinks](https://cursor.com/docs/context/mcp/install-links).

### VS Code

Konfigurieren Sie den Server in VS Code in `.vscode/mcp.json` unter dem Schlüssel `servers` auf oberster Ebene mit `type: "http"`:

```json
{
  "servers": {
    "blockvectra": {
      "type": "http",
      "url": "https://docs.blockvectra.com/mcp"
    }
  }
}
```

Wenn Sie authentifizierte Tools benötigen, fügen Sie das Objekt `headers` hinzu:

```json
{
  "servers": {
    "blockvectra": {
      "type": "http",
      "url": "https://docs.blockvectra.com/mcp",
      "headers": {
        "x-api-key": "YOUR_API_KEY"
      }
    }
  }
}
```

Zum Speichern sensibler Zugangsdaten unterstützt VS Code Verweise auf Eingabevariablen oder Umgebungsdateien, statt Keys fest einzutragen. Server lassen sich auch über die Command-Palette-Aktion `MCP: Add Server` hinzufügen.

Offizielle Dokumentation: [VS-Code-Dokumentation zu MCP-Servern](https://code.visualstudio.com/docs/copilot/customization/mcp-servers) und [VS-Code-Referenz zur MCP-Konfiguration](https://code.visualstudio.com/docs/agents/reference/mcp-configuration).

### Codex

Fügen Sie den Server mit der OpenAI Codex CLI hinzu:

```bash
codex mcp add blockvectra --url https://docs.blockvectra.com/mcp
```

Konfigurieren Sie die Server-URL in `config.toml`:

```toml
[mcp_servers.blockvectra]
url = "https://docs.blockvectra.com/mcp"
```

Wenn Sie authentifizierte Tools benötigen, konfigurieren Sie die Request-Header in `config.toml`:

```toml
[mcp_servers.blockvectra]
url = "https://docs.blockvectra.com/mcp"
http_headers = { "x-api-key" = "YOUR_API_KEY" }
```

Alternativ ordnen Sie den Header einer Umgebungsvariablen zu:

```toml
[mcp_servers.blockvectra]
url = "https://docs.blockvectra.com/mcp"
env_http_headers = { "x-api-key" = "BLOCKVECTRA_API_KEY" }
```

Offizielle Dokumentation: [MCP-Dokumentation der OpenAI Codex CLI](https://learn.chatgpt.com/docs/extend/mcp?surface=cli).

### Gemini CLI

Fügen Sie den Server in der Gemini-CLI-Konfiguration unter `mcpServers` hinzu und verwenden Sie `httpUrl` für Streamable HTTP:

```json
{
  "mcpServers": {
    "blockvectra": {
      "httpUrl": "https://docs.blockvectra.com/mcp"
    }
  }
}
```

Wenn Sie authentifizierte Tools benötigen, fügen Sie das Objekt `headers` mit Ihrem API key hinzu:

```json
{
  "mcpServers": {
    "blockvectra": {
      "httpUrl": "https://docs.blockvectra.com/mcp",
      "headers": {
        "x-api-key": "YOUR_API_KEY"
      }
    }
  }
}
```

Offizielle Dokumentation: [Gemini-CLI-Dokumentation zum MCP-Server](https://github.com/google-gemini/gemini-cli/blob/main/docs/tools/mcp-server.md).

### OpenAI Responses API

Übergeben Sie beim Aufruf der OpenAI Responses API den MCP-Server im Array `tools` mit `type: "mcp"`:

```bash
OPENAI_API_BASE="https://api.openai.com/v1"
curl "$OPENAI_API_BASE/responses" \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "<model>",
    "tools": [{
      "type": "mcp",
      "server_label": "blockvectra",
      "server_url": "https://docs.blockvectra.com/mcp",
      "require_approval": "never"
    }],
    "input": "..."
  }'
```

Wenn Sie authentifizierte Tools benötigen, nehmen Sie das Feld `headers` in die Tool-Definition auf:

```json
{
  "type": "mcp",
  "server_label": "blockvectra",
  "server_url": "https://docs.blockvectra.com/mcp",
  "headers": { "x-api-key": "YOUR_API_KEY" },
  "require_approval": "never"
}
```

Offizielle Dokumentation: [OpenAI-Leitfaden zu MCP-Tools](https://developers.openai.com/api/docs/guides/tools-connectors-mcp) und [OpenAI-Responses-API-Referenz](https://developers.openai.com/api/reference/resources/responses/methods/create).

### Windsurf

Konfigurieren Sie den Server in Windsurf unter `mcpServers` mit dem Feld `serverUrl`:

```json
{
  "mcpServers": {
    "blockvectra": {
      "serverUrl": "https://docs.blockvectra.com/mcp"
    }
  }
}
```

Wenn Sie authentifizierte Tools benötigen, fügen Sie das Objekt `headers` mit Ihrem API key hinzu:

```json
{
  "mcpServers": {
    "blockvectra": {
      "serverUrl": "https://docs.blockvectra.com/mcp",
      "headers": {
        "x-api-key": "YOUR_API_KEY"
      }
    }
  }
}
```

Windsurf unterstützt außerdem Verweise auf Umgebungsvariablen, etwa `"x-api-key": "${env:BLOCKVECTRA_API_KEY}"`.

Offizielle Dokumentation: [Windsurf-MCP-Dokumentation](https://docs.devin.ai/desktop/cascade/mcp).

### Claude Desktop und claude.ai

Benutzerdefinierte Konnektoren werden über die Benutzeroberfläche eingerichtet:

* **claude.ai**: Gehen Sie zu **Customize** > **Connectors**, klicken Sie auf **+ Add**, wählen Sie **Add custom connector** und geben Sie die URL ein:
  ```text
  https://docs.blockvectra.com/mcp
  ```
* **Claude Desktop**: Öffnen Sie das Kontoeinstellungsmenü und richten Sie benutzerdefinierte Konnektoren über die Konnektoren-Oberfläche ein.

Mit der Verbindung zu dieser URL kann Claude ohne Zugangsdaten Leitfäden durchsuchen, Markdown-Dokumentation lesen, unterstützte Chains einsehen, den Netzwerkstatus prüfen und Preisschätzungen berechnen.

Offizielle Dokumentation: [Leitfaden zu benutzerdefinierten Konnektoren von Claude](https://support.claude.com/en/articles/11175166-getting-started-with-custom-connectors-using-remote-mcp).

### Verbindung prüfen und Fehler beheben

In Claude Code zeigt `claude mcp list` den Status jedes Servers. Um die Zahl der tatsächlich registrierten Tools zu erfahren, führen Sie einmal mit Stream-Ausgabe aus und lesen Sie das `init`-Event, oder lesen Sie das Debug-Log:

```bash
claude -p "say ok" --mcp-config ./mcp.json --output-format stream-json --verbose
claude -p "say ok" --mcp-config ./mcp.json --debug mcp --debug-file mcp-debug.log
```

Eine funktionierende Verbindung zeigt im `init`-Event `"status": "connected"` und die Tools `mcp__blockvectra-docs__*` (etwa `list_chains` und `rpc_call`). Suchen Sie im Debug-Log nach Zeilen zu `blockvectra-docs` wie `Successfully connected` und `Failed to fetch tools`. Ist der Server `connected`, es erscheinen aber keine Tools, lesen Sie den Grund, den das Debug-Log (`--debug mcp`) nach `Failed to fetch tools` meldet. Ob der Server selbst gesund ist, prüfen Sie mit den curl-Aufrufen unten.

### MCP-Endpunkt ohne Client aufrufen

Der Endpunkt ist JSON-RPC 2.0 über HTTP POST, daher kann ihn jeder HTTP-Client aufrufen:

```bash
curl -s https://docs.blockvectra.com/mcp -H 'content-type: application/json' \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'

curl -s https://docs.blockvectra.com/mcp -H 'content-type: application/json' \
  -d '{"jsonrpc":"2.0","id":2,"method":"tools/call","params":{"name":"rpc_call","arguments":{"chain":"base_mainnet","method":"eth_blockNumber","params":[]}}}'
```

Der erste Aufruf liefert die Tool-Liste; der zweite liefert die JSON-RPC-Antwort in `result.structuredContent`. Chain-Kennungen sind Slugs wie `base_mainnet`; Sie erhalten sie über `list_chains`. Tools mit Key-Pflicht benötigen den Header `x-api-key`; dieser Aufruf liest Ihr Konto mit dem Key aus einer Umgebungsvariablen:

```bash
curl -s https://docs.blockvectra.com/mcp -H 'content-type: application/json' \
  -H "x-api-key: $BLOCKVECTRA_API_KEY" \
  -d '{"jsonrpc":"2.0","id":3,"method":"tools/call","params":{"name":"get_account","arguments":{}}}'
```

Er liefert `key_id`, `plan`, `balance_units`, `balance_cu` und die Ratenlimits des Keys in `result.structuredContent`. Führt Ihr Agent Befehle über eine berechtigungsgeschützte Shell aus, kann diese Variablenexpansion blockiert werden; konfigurieren Sie den Header dann stattdessen im MCP-Client.

## FAQ

### Benötigt der BlockVectra-MCP-Server einen API key?

Nein. Für die Verbindung ist kein Key nötig, und 10 der 15 Tools brauchen nie einen. `rpc_call` und `send_raw_transaction` laufen nur für Methoden aus den `public.methods` der Chain ohne Key (auslesbar über `list_chains`). `data_api_get`, `get_account` und `get_deposit_address` benötigen den Header `x-api-key`.

### Kann der MCP-Server API keys erstellen oder widerrufen?

Nein. Kein Tool erstellt, listet oder widerruft API keys. `how_to_get_api_key` liefert nur die Schritte; ein Agent erstellt einen Key über HTTP nach der [programmatischen Registrierung](https://docs.blockvectra.com/de/guides/programmatic-signup/?ref=docs-mcp-server), und Personen erstellen ihn in der Konsole. Keys laufen nie über Tool-Argumente.

### Kann ein Agent Transaktionen über den MCP-Server senden?

Er kann senden, aber nicht signieren. `rpc_call` lehnt schreibende Methoden wie `eth_sendRawTransaction`, `eth_sendTransaction`, `eth_sign` und `personal_*` ab. `send_raw_transaction` sendet mit `eth_sendRawTransaction` eine Transaktion, die Sie lokal bereits signiert haben; der Server hält oder sieht nie einen privaten Schlüssel.

### Was passiert, wenn ein Aufruf fehlschlägt?

Tool-Fehler liefern `isError: true` mit einem strukturierten Grund. Mit `explain_error` oder der [Referenz der Fehlercodes](https://docs.blockvectra.com/de/errors/) sehen Sie, ob ein Fehlschlag abgerechnet wird und ob ein erneuter Versuch sinnvoll ist.

## Weiterführend

* [KI-Agenten verbinden](https://docs.blockvectra.com/de/guides/ai-agents/): maschinenlesbare Dateien, öffentliche JSON-Endpunkte und der Ablauf zur Chain-Auswahl.
* [Programmatische Registrierung](https://docs.blockvectra.com/de/guides/programmatic-signup/?ref=docs-mcp-server): einen API key per Wallet-Signatur erstellen, ohne Browser.
* [Rezepte für Agent-Frameworks](https://docs.blockvectra.com/de/guides/agent-frameworks/): ElizaOS, viem, wagmi und Coinbase AgentKit.
* [Fehlercodes](https://docs.blockvectra.com/de/errors/): jeder Fehler mit Abrechnungs- und Wiederholungsregeln.
