Möchten Sie die Fähigkeiten Ihres KI-Assistenten mit Echtzeit-Websuchen aufladen? Stellen Sie sich vor, Ihr Lieblings-Large Language Model (LLM), wie Claude oder GPT-4o, flitzt durch das Internet, um die neuesten Nachrichten abzurufen oder ein gemütliches Café in der Nähe zu finden – alles angetrieben von der Brave Search API und einem benutzerdefinierten MCP-Server. Das Model Context Protocol (MCP) ist wie ein USB-Anschluss für KI, der es ermöglicht, sich mit Tools wie der Brave Search API zu verbinden, um epische Daten abzurufen. In diesem Leitfaden für Anfänger zeige ich Ihnen Schritt für Schritt, wie Sie einen MCP-Server erstellen, der die Brave Search API nutzt, mit einer Gesprächsatmosphäre, die so entspannt ist wie ein sonniger Nachmittag. Kein Doktortitel erforderlich – nur ein bisschen Neugier und eine Tastatur. Bereit, Ihre KI zu einem Suchzauberer zu machen? Los geht's!

Was ist ein MCP-Server mit Brave Search API?
Also, was ist dieses MCP-Server-Ding? Das Model Context Protocol (MCP) ist ein offener Standard von Anthropic, der es KI-Modellen wie Claude ermöglicht, sich über ein Client-Server-Setup mit externen Tools und Datenquellen zu verbinden. Ein MCP-Server ist wie ein Mittelsmann, der Tools – denken Sie an Websuche, Dateizugriff oder sogar GitHub-Integration – Ihrer KI über standardisierte API-ähnliche Aufrufe zur Verfügung stellt. Die Brave Search API ist derweil eine datenschutzorientierte Suchmaschinen-API, die Web- und lokale Suchergebnisse liefert, mit Funktionen wie Paginierung, Frischekontrollen und intelligenten Fallbacks (z. B. Wechsel zur Websuche, wenn lokale Ergebnisse leer sind).
Indem Sie beides kombinieren, erstellen Sie einen MCP-Server, mit dem Ihre KI die Brave Search API nach Echtzeitinformationen abfragen kann – z. B. um die beste Pizza der Stadt oder die neuesten Tech-Nachrichten zu finden – ohne ihre gemütliche KI-Umgebung zu verlassen. Warum ist das cool? Es ist privat, schnell und verleiht Ihrer KI Superkräfte. Bauen wir einen!
Einrichten Ihrer Umgebung für den Brave Search MCP-Server: Die Grundlagen
Bevor wir unseren MCP-Server programmieren, bereiten wir Ihr System vor. Das Setup ist unkompliziert, aber wir gehen langsam vor, um es anfängerfreundlich zu halten.
Schritt 1: Voraussetzungen
Sie benötigen:
- Python: Version 3.9+ zum Ausführen des Servers. Überprüfen Sie mit
python --version
. Kein Python? Holen Sie es sich von python.org. - Node.js: Zum Ausführen des Brave Search MCP-Servers über
npx
. Überprüfen Sie mitnode --version
. Holen Sie es sich unter nodejs.org. - Brave Search API Key: Melden Sie sich unter brave.com/search/api an, wählen Sie einen Plan (die kostenlose Stufe bietet 2.000 Abfragen/Monat) und generieren Sie Ihren Schlüssel über das Dashboard.
- Text Editor: VS Code oder ein beliebiger Editor zum Anpassen von Konfigurationen.
- Terminal: Terminal (Mac/Linux) oder PowerShell (Windows).
Schritt 2: Erstellen Sie einen Projektordner
Halten wir die Dinge ordentlich:
mkdir brave-mcp-server
cd brave-mcp-server
Schritt 3: Richten Sie eine virtuelle Umgebung ein
Um Paketchaos zu vermeiden, erstellen Sie eine virtuelle Python-Umgebung:
python -m venv venv
Aktivieren Sie sie:
- Mac/Linux:
source venv/bin/activate
- Windows:
venv\Scripts\activate
Sie sehen (venv)
in Ihrem Terminal – gut!
Den Brave Search API-Schlüssel abrufen
Die Brave Search API benötigt einen API-Schlüssel, um zu funktionieren. So schnappen Sie sich einen:
- Besuchen Sie brave.com/search/api und melden Sie sich an.
- Wählen Sie die kostenlose Stufe (2.000 Abfragen/Monat) oder einen kostenpflichtigen Plan, wenn Sie groß rauskommen wollen.
- Klicken Sie im Entwickler-Dashboard auf „API-Schlüssel generieren“. Kopieren Sie ihn und speichern Sie ihn an einem sicheren Ort (nicht in einem öffentlichen Repository!).

Wir werden diesen Schlüssel in Kürze sicher speichern. Lassen Sie uns vorerst die MCP-Server-Tools installieren.
Installieren des Brave Search MCP-Servers
Der Brave Search MCP-Server ist über npm verfügbar, was die Einrichtung mit Node.js zum Kinderspiel macht. Installieren wir ihn:
Schritt 1: Abhängigkeiten installieren
Installieren Sie mit Ihrer aktiven virtuellen Umgebung Python-Pakete für MCP-Client-Interaktionen:
pip install requests aiohttp asyncio python-dotenv
Diese verarbeiten HTTP-Anfragen und Umgebungsvariablen. Node.js verarbeitet den Server selbst, also stellen Sie sicher, dass er installiert ist.
Schritt 2: Testen Sie das Brave Search MCP-Paket
Führen Sie das Serverpaket aus, um zu bestätigen, dass es zugänglich ist:
npx -y @modelcontextprotocol/server-brave-search
Wenn es Fehler gibt (z. B. „BRAVE_API_KEY not set“), keine Sorge – das konfigurieren wir als Nächstes. Wenn es läuft und wartet, sind Sie goldrichtig. Unter Windows kann es zu einem ENOENT
-Fehler kommen, wenn npx
nicht gefunden wird – versuchen Sie, den vollständigen Node.js-Pfad zu verwenden (dazu später mehr).
Konfigurieren des Brave Search MCP-Servers
Okay, lassen Sie uns Ihren MCP-Server bereit machen, um die Brave Search API zu nutzen! Dazu müssen Sie die MCP-Server-Konfigurationsdatei für Ihre IDE oder Ihren MCP-Client Ihrer Wahl öffnen – z. B. claude_desktop_config.json
für Claude Desktop, .cursor/mcp.json
für Cursor, .codium/windsurf/mcp_config.json
für Codium/Windsurf oder settings.json
für VS Code – und einige spezifische Einstellungen hinzufügen. Wir werden auch Ihren Brave Search API-Schlüssel sicher speichern, um die Dinge sicher zu halten. Machen wir das Schritt für Schritt!
Schritt 1: Erstellen Sie eine .env-Datei
Um Ihren Brave Search API-Schlüssel sicher aufzubewahren, verwenden wir eine .env
-Datei:
touch .env
Öffnen Sie sie in Ihrem bevorzugten Editor und fügen Sie Folgendes hinzu:
BRAVE_API_KEY=your-api-key-here
Ersetzen Sie your-api-key-here
durch Ihren tatsächlichen Brave Search API-Schlüssel aus dem Brave-Dashboard. Speichern Sie die Datei und fügen Sie .env
zu Ihrem .gitignore
hinzu, um sie privat zu halten – niemand muss Ihre Geheimnisse sehen! Auf diese Weise kann Ihr MCP-Server den Schlüssel abrufen, ohne ihn fest zu codieren.
Schritt 2: Aktualisieren Sie die MCP-Konfigurationsdatei Ihrer IDE
Öffnen Sie nun die MCP-Server-Konfigurationsdatei für Ihre IDE oder Ihren Client. Je nachdem, was Sie verwenden, könnte dies Folgendes sein:
- Claude Desktop:
claude_desktop_config.json
(Mac:~/Library/Application Support/Claude/claude_desktop_config.json
, Windows:%UserProfile%\AppData\Roaming\Claude\claude_desktop_config.json
) - Cursor:
.cursor/mcp.json
(normalerweise in Ihrem Projekt- oder Home-Verzeichnis) - Codium/Windsurf:
.codium/windsurf/mcp_config.json
(überprüfen Sie~/.codium/windsurf/
) - VS Code:
settings.json
(finden Sie es überCode > Preferences > Settings > Extensions > MCP
oder~/.vscode/settings.json
)
Wenn die Datei nicht existiert, erstellen Sie sie am entsprechenden Ort (z. B. verwenden Sie touch claude_desktop_config.json
für Claude). Öffnen Sie sie in Ihrem Editor und fügen Sie die folgende Konfiguration hinzu, um Ihrem MCP-Server mitzuteilen, wie der Brave Search-Dienst ausgeführt werden soll.
Für Mac/Linux:
{
"mcpServers": {
"brave-search": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-brave-search"],
"env": {
"BRAVE_API_KEY": "$BRAVE_API_KEY"
},
"disabled": false,
"alwaysAllow": []
}
}
}
Für Windows:
{
"mcpServers": {
"brave-search": {
"command": "C:\\Program Files\\nodejs\\node.exe",
"args": ["C:\\Users\\YourUsername\\AppData\\Roaming\\npm\\node_modules\\@modelcontextprotocol\\server-brave-search\\dist\\index.js"],
"env": {
"BRAVE_API_KEY": "$BRAVE_API_KEY"
},
"disabled": false,
"alwaysAllow": []
}
}
}
Ein paar Anmerkungen:
- API-Schlüssel: Die Zeile
"BRAVE_API_KEY": "$BRAVE_API_KEY"
ruft Ihren Schlüssel aus der.env
-Datei mitpython-dotenv
ab (mehr dazu im Client-Skript später). Wenn Sie möchten, ersetzen Sie$BRAVE_API_KEY
durch Ihren tatsächlichen Schlüssel (z. B."sk-xxx"
), aber die.env
-Methode ist sicherer. - Windows-Pfad: Ersetzen Sie für Windows
YourUsername
durch Ihren tatsächlichen Benutzernamen. Um den genauen Node.js-Pfad zu finden, führen SieGet-Command node | Select-Object Source
in PowerShell oderwhere node
in der Eingabeaufforderung aus. Suchen Sie für denargs
-Pfad das Modul@modelcontextprotocol/server-brave-search
in Ihren globalen npm-Modulen (normalerweiseC:\Users\YourUsername\AppData\Roaming\npm\node_modules
). Wenn Sie einenENOENT
-Fehler erhalten, überprüfen Sie diese Pfade noch einmal. - Konfigurationen zusammenführen: Wenn Ihre Konfigurationsdatei bereits ein
mcpServers
-Objekt hat, fügen Sie einfach den Eintrag"brave-search"
hinzu, z. B.:
{
"mcpServers": {
"existing-server": { ... },
"brave-search": { ... }
}
}
Schritt 3: Speichern und überprüfen
Speichern Sie die Konfigurationsdatei am richtigen Ort für Ihre IDE oder Ihren Client:
- Claude Desktop: Mac:
~/Library/Application Support/Claude/claude_desktop_config.json
, Windows:%UserProfile%\AppData\Roaming\Claude\claude_desktop_config.json
- Cursor: Platzieren Sie
.cursor/mcp.json
in Ihrem Projektstammverzeichnis oder Home-Verzeichnis (~/.cursor/
). - Codium/Windsurf: Speichern Sie
.codium/windsurf/mcp_config.json
in~/.codium/windsurf/
. - VS Code: Aktualisieren Sie
settings.json
in~/.vscode/
oder über die VS Code-Einstellungs-UI.
Wenn der Ordner nicht existiert, erstellen Sie ihn (z. B. mkdir -p ~/Library/Application Support/Claude
auf dem Mac). Diese Konfiguration teilt Ihrem MCP-Client (wie Claude oder Cursor) mit, wie der MCP-Server für die Brave Search API gestartet wird. Um zu testen, starten Sie Ihre IDE oder Ihren Client neu, um die neuen Einstellungen zu laden – wir werden überprüfen, ob es funktioniert, wenn wir das Client-Skript später ausführen!
Erstellen eines einfachen MCP-Clients zum Testen des Brave Search MCP-Servers
Erstellen wir ein Python-Skript, um Ihren MCP-Server mit der Brave Search API zu testen. Dieser Client ahmt nach, wie Claude Desktop mit dem Server interagiert.
Schritt 1: Erstellen Sie das Client-Skript
Erstellen Sie brave_mcp_client.py
:
import asyncio
import os
from dotenv import load_dotenv
from fastmcp.client import MCPClient
async def main():
# Load environment variables
load_dotenv()
# Create MCPClient from config file
client = MCPClient.from_config_file("claude_desktop_config.json")
# Make a search query
response = await client.request(
{"method": "brave_web_search"},
{"query": "best coffee shops in Seattle", "count": 10}
)
print(f"Search Results: {response}")
if __name__ == "__main__":
asyncio.run(main())
Dieses Skript:
- Lädt Ihren Brave Search API-Schlüssel aus
.env
. - Verwendet
fastmcp
, um sich mit dem MCP-Server zu verbinden. - Sendet eine Websuchanfrage über das Tool
brave_web_search
.
Schritt 2: Installieren Sie fastmcp
Installieren Sie die MCP-Client-Bibliothek:
pip install fastmcp
Schritt 3: Führen Sie den Client aus
Mit Ihrer aktiven virtuellen Umgebung:
python brave_mcp_client.py
Wenn alles gut geht, startet der MCP-Server, fragt die Brave Search API ab und gibt Ergebnisse wie eine JSON-Liste von Cafés aus. Ich habe in Sekundenschnelle eine leckere Liste von Cafés in Seattle erhalten! Wenn Sie Fehler sehen, überprüfen Sie Folgendes:
- API-Schlüssel: Stellen Sie sicher, dass er in
.env
oder der Konfiguration gültig ist. - Protokolle: Gehen Sie unter Claude Desktop zu Einstellungen > Entwickler, um Protokolle in
%UserProfile%\AppData\Roaming\Claude\Logs\
(Windows) oder~/Library/Application Support/Claude/Logs/
(Mac) anzuzeigen. - Node.js-Pfad: Windows-Benutzer, überprüfen Sie den
command
-Pfad in der Konfiguration.
Integrieren der Brave Search API mit Claude Desktop
So verwenden Sie Ihren MCP-Server mit Claude Desktop:
- Claude Desktop installieren: Laden Sie es von der offiziellen Website von Anthropic herunter und installieren Sie es.
- Konfiguration hinzufügen: Stellen Sie sicher, dass sich
claude_desktop_config.json
im richtigen Ordner befindet (siehe oben). - Claude neu starten: Beenden Sie es vollständig (Command+Q auf dem Mac) und öffnen Sie es erneut.
- Eine Abfrage testen: Geben Sie in Claudes Chat Folgendes ein: „Suchen Sie im Web nach den besten Cafés in Seattle.“ Claude fordert Sie auf, die Erlaubnis zur Verwendung des MCP-Servers zu erteilen, und zeigt dann die Ergebnisse an.

Sie sollten sehen, wie Claude „Making a tool request: brave_web_search“ protokolliert und Ergebnisse über die Brave Search API abruft. Mein Test hat fantastische Kaffee-Spots ohne Probleme hervorgebracht!
Für andere KI-gestützte IDEs wie Codium/Windsurf, VS Code und Cursor. Durch die Wiederverwendung derselben Brave Search API-Konfiguration können Sie diese Tools in die Lage versetzen, Websuchen über den MCP-Server durchzuführen, sodass KI-Assistenten Echtzeitdaten direkt in der Chat-Oberfläche jeder IDE abrufen können. Der Prozess ist ähnlich und beinhaltet das Einfügen der vorhandenen Konfiguration in die entsprechenden MCP-Einstellungen für jede IDE, mit geringfügigen Anpassungen für Windows-Benutzer, um sicherzustellen, dass die Node.js-Pfade wie oben erwähnt korrekt sind.
Und für ausführlichere Anleitungen zur Konfiguration von MCP-Servern in verschiedenen Umgebungen besuchen Sie apidog.com/blog, wo Sie hilfreiche Ressourcen finden, um die Brave Search API (und viele andere MCP-Server) nahtlos in Ihre bevorzugten Coding-Tools zu integrieren.
Warum die Brave Search API mit einem MCP-Server verwenden?
Diese Kombination rockt, weil:
- Echtzeitdaten: Die Brave Search API erfasst aktuelle Web- und lokale Ergebnisse, im Gegensatz zu statischem LLM-Wissen.
- Datenschutzfokus: Braves datenschutzorientierter Ansatz sorgt für sichere Suchvorgänge.
- Einfache Integration: Das MCP-Server-Setup ist Plug-and-Play mit Tools wie Claude.
Im Vergleich zum MCP-Server von Perplexity bietet die API von Brave lokale Suchvorgänge und flexible Filter, was sie zu einer Top-Auswahl macht.
Profi-Tipps für den Brave Search MCP-Erfolg
- Konfiguration validieren: Verwenden Sie einen JSON-Linter, um Tippfehler in
claude_desktop_config.json
zu erkennen. - Protokolle überprüfen: Beheben Sie Fehler mit den Entwicklereinstellungen von Claude, wenn der Server ausfällt.
- Lokale Suche ausprobieren: Fragen Sie nach „Restaurants in meiner Nähe“, um den lokalen Fallback der Brave Search API zu testen.
- Weitere Server erkunden: Suchen Sie auf mcp.so nach Servern wie Firecrawl (Web-Scraping) oder GitHub.
Fazit: Ihr Brave Search MCP-Abenteuer beginnt
Herzlichen Glückwunsch – Sie haben einen MCP-Server erstellt, der die Brave Search API nutzt, um Ihre KI zu einem Such-Superstar zu machen! Von der Einrichtung von Node.js bis zur Abfrage von Cafés mit Claude sind Sie jetzt bereit, das Web mit KI zu erkunden. Versuchen Sie als Nächstes, nach Nachrichten, lokalen Diensten oder sogar Nischenthemen zu suchen. Die MCP-Server-Liste enthält weitere Tools zum Spielen, und die Claude MCP-Community auf claudemcp.com sprüht vor Ideen. Also, was ist Ihre nächste Abfrage? Neueste Tech-Trends? Ein verstecktes Juwel-Restaurant? Und vergessen Sie nicht, apidog.com für den zusätzlichen API-Feinschliff zu besuchen.
