Probando el Servidor Brave MCP (con la API de Brave Search), Aquí están Mis Pensamientos:

¿Te gustaría potenciar las habilidades de tu asistente de IA con búsquedas web en tiempo real? Imagina tu modelo de lenguaje favorito (LLM), como Claude o GPT-4o, navegando por internet para obtener las últimas noticias o encontrar un café acogedor cerca, todo impulsado por la API de Brave Search y un servidor MCP personalizado. El Protocolo de Contexto del Modelo (MCP) es como un puerto USB para la IA, permitiéndole conectarse a herramientas como la API de Brave Search para una recuperación de datos épica. En esta guía para principiantes, te guiaré paso a paso sobre cómo construir un servidor MCP que se conecte a la API de Brave Search, con una vibra conversacional tan relajada como una tarde soleada. No se necesita un doctorado, solo un poco de curiosidad y un teclado. ¿Listo para convertir tu IA en un mago de las búsquedas? ¡Vamos a sumergirnos!

¿Qué es un servidor MCP con la API de Brave Search?

Entonces, ¿qué es este servidor MCP? El Protocolo de Contexto del Modelo (MCP) es un estándar abierto de Anthropic que permite a los modelos de IA, como Claude, conectarse a herramientas y fuentes de datos externas a través de una configuración cliente-servidor. Un servidor MCP es como un intermediario que expone herramientas—piensa en búsqueda web, acceso a archivos o incluso integración de GitHub—para tu IA a través de llamadas estandarizadas al estilo API. La API de Brave Search, por otro lado, es un motor de búsqueda enfocado en la privacidad que entrega resultados de búsqueda web y locales, con características como paginación, controles de frescura y retrocesos inteligentes (por ejemplo, cambiar a búsqueda web si los resultados locales están vacíos).

Al combinar ambos, creas un servidor MCP que permite a tu IA consultar la API de Brave Search para obtener información en tiempo real—como encontrar la mejor pizza en la ciudad o las últimas noticias tecnológicas—sin salir de su acogedor entorno de IA. ¿Por qué es genial? Es privado, rápido y le da superpoderes a tu IA. ¡Vamos a construir uno!

Configurando tu entorno para el servidor MCP de Brave Search: Lo básico

Antes de codificar nuestro servidor MCP, preparemos tu sistema. La configuración es sencilla, pero iremos despacio para que sea amigable para principiantes.

Paso 1: Requisitos previos

Necesitarás:

• Python: Versión 3.9+ para ejecutar el servidor. Verifica con python --version. ¿Sin Python? Consíguelo en python.org.
• Node.js: Para ejecutar el servidor MCP de Brave Search a través de npx. Verifica con node --version. Consíguelo en nodejs.org.
• Clave de API de Brave Search: Regístrate en brave.com/search/api, elige un plan (el nivel gratuito ofrece 2,000 consultas/mes) y genera tu clave desde el panel de control.
• Editor de texto: VS Code o cualquier editor para ajustar configuraciones.
• Terminal: Terminal (Mac/Linux) o PowerShell (Windows).

Paso 2: Crea una carpeta de proyecto

Mantengamos las cosas ordenadas:

mkdir brave-mcp-server
cd brave-mcp-server

Paso 3: Configura un entorno virtual

Para evitar el caos de paquetes, crea un entorno virtual de Python:

python -m venv venv

Actívalo:

• Mac/Linux: source venv/bin/activate
• Windows: venv\Scripts\activate

Verás (venv) en tu terminal—¡genial!

Obteniendo la clave de API de Brave Search

La API de Brave Search necesita una clave de API para funcionar. Aquí te explico cómo obtener una:

1. Visita brave.com/search/api y regístrate.
2. Elige el nivel gratuito (2,000 consultas/mes) o un plan de pago si deseas algo más.
3. En el panel de desarrolladores, haz clic en “Generar clave de API.” Cópiala y guárdala en un lugar seguro (¡no en un repositorio público!).

Guardaremos esta clave de manera segura en un momento. Por ahora, instalemos las herramientas del servidor MCP.

Instalando el servidor MCP de Brave Search

El servidor MCP de Brave Search está disponible a través de npm, lo que hace que la configuración sea fácil con Node.js. Vamos a instalarlo:

Paso 1: Instalar dependencias

Con tu entorno virtual activo, instala paquetes de Python para interacciones con el cliente MCP:

pip install requests aiohttp asyncio python-dotenv

Estos manejan solicitudes HTTP y variables de entorno. Node.js maneja el servidor en sí, así que asegúrate de que esté instalado.

Paso 2: Probar el paquete MCP de Brave Search

Ejecuta el paquete del servidor para confirmar que es accesible:

npx -y @modelcontextprotocol/server-brave-search

Si aparece un error (por ejemplo, “BRAVE_API_KEY no configurada”), no te preocupes, configuraremos eso a continuación. Si se ejecuta y espera, estás en buen camino. En Windows, podrías encontrar un error ENOENT si npx no se encuentra—intenta usar la ruta completa de Node.js (más sobre eso más adelante).

Configurando el servidor MCP de Brave Search

Bien, ¡preparémonos para que tu servidor MCP se conecte a la API de Brave Search! Para hacer esto, necesitarás abrir el archivo de configuración del servidor MCP para tu IDE o cliente MCP de elección—como claude_desktop_config.json para Claude Desktop, .cursor/mcp.json para Cursor, .codium/windsurf/mcp_config.json para Codium/Windsurf, o settings.json para VS Code—y agregar algunas configuraciones específicas. También almacenaremos tu clave de API de Brave Search de manera segura para mantener las cosas a salvo. ¡Hagámoslo paso a paso!

Paso 1: Crear un archivo .env

Para mantener tu clave de API de Brave Search a salvo, usaremos un archivo .env:

touch .env

Ábrelo en tu editor favorito y agrega:

BRAVE_API_KEY=tu-clave-api-aquí

Reemplaza tu-clave-api-aquí con tu clave real de API de Brave Search del panel de Brave. Guarda el archivo y agrega .env a tu .gitignore para mantenerlo privado—¡nadie necesita ver tus secretos! De esta manera, tu servidor MCP puede obtener la clave sin codificarla directamente.

Paso 2: Actualiza el archivo de configuración MCP de tu IDE

Ahora, abre el archivo de configuración del servidor MCP para tu IDE o cliente. Dependiendo de lo que estés usando, este podría ser:

• 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 (generalmente en tu proyecto o directorio personal)
• Codium/Windsurf: .codium/windsurf/mcp_config.json (verifica ~/.codium/windsurf/)
• VS Code: settings.json (encuéntralo a través de Code > Preferences > Settings > Extensions > MCP o ~/.vscode/settings.json)

Si el archivo no existe, créalo en la ubicación adecuada (por ejemplo, usa touch claude_desktop_config.json para Claude). Ábrelo en tu editor y agrega la siguiente configuración para indicar a tu servidor MCP cómo ejecutar el servicio de Brave Search.

Para Mac/Linux:

{
  "mcpServers": {
    "brave-search": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-brave-search"],
      "env": {
        "BRAVE_API_KEY": "$BRAVE_API_KEY"
      },
      "disabled": false,
      "alwaysAllow": []
    }
  }
}

Para Windows:

{
  "mcpServers": {
    "brave-search": {
      "command": "C:\\Program Files\\nodejs\\node.exe",
      "args": ["C:\\Users\\TuNombreDeUsuario\\AppData\\Roaming\\npm\\node_modules\\@modelcontextprotocol\\server-brave-search\\dist\\index.js"],
      "env": {
        "BRAVE_API_KEY": "$BRAVE_API_KEY"
      },
      "disabled": false,
      "alwaysAllow": []
    }
  }
}

Algunas notas:

• Clave de API: La línea "BRAVE_API_KEY": "$BRAVE_API_KEY" obtiene tu clave del archivo .env usando python-dotenv (más sobre eso en el script del cliente más adelante). Si prefieres, reemplaza $BRAVE_API_KEY con tu clave real (por ejemplo, "sk-xxx"), pero el método .env es más seguro.
• Ruta de Windows: Para Windows, reemplaza TuNombreDeUsuario con tu nombre de usuario real. Para encontrar la ruta exacta de Node.js, ejecuta Get-Command node | Select-Object Source en PowerShell o where node en el Símbolo del sistema. Para la ruta en args, localiza el módulo @modelcontextprotocol/server-brave-search en tus módulos globales de npm (generalmente C:\Users\TuNombreDeUsuario\AppData\Roaming\npm\node_modules). Si encuentras un error ENOENT, verifica estas rutas.
• Fusionando configuraciones: Si tu archivo de configuración ya tiene un objeto mcpServers, simplemente agrega la entrada "brave-search" a él, así:

{
  "mcpServers": {
    "servidor-existente": { ... },
    "brave-search": { ... }
  }
}

Paso 3: Guardar y verificar

Guarda el archivo de configuración en la ubicación correcta para tu IDE o cliente:

• Claude Desktop: Mac: ~/Library/Application Support/Claude/claude_desktop_config.json, Windows: %UserProfile%\AppData\Roaming\Claude\claude_desktop_config.json
• Cursor: Coloca .cursor/mcp.json en la raíz de tu proyecto o directorio personal (~/.cursor/).
• Codium/Windsurf: Guarda .codium/windsurf/mcp_config.json en ~/.codium/windsurf/.
• VS Code: Actualiza settings.json en ~/.vscode/ o a través de la interfaz de configuración de VS Code.

Si la carpeta no existe, créala (por ejemplo, mkdir -p ~/Library/Application Support/Claude en Mac). Esta configuración le dice a tu cliente MCP (como Claude o Cursor) cómo iniciar el servidor MCP para la API de Brave Search. Para probar, reinicia tu IDE o cliente para cargar la nueva configuración—¡verificaremos que funcione cuando ejecutemos el script del cliente más adelante!

Construyendo un cliente MCP simple para probar el servidor MCP de Brave Search

Creemos un script en Python para probar tu servidor MCP con la API de Brave Search. Este cliente imitará cómo Claude Desktop interactúa con el servidor.

Paso 1: Crear el script del cliente

Crea brave_mcp_client.py:

import asyncio
import os
from dotenv import load_dotenv
from fastmcp.client import MCPClient

async def main():
    # Cargar variables de entorno
    load_dotenv()

    # Crear MCPClient desde el archivo de configuración
    client = MCPClient.from_config_file("claude_desktop_config.json")

    # Hacer una consulta de búsqueda
    response = await client.request(
        {"method": "brave_web_search"},
        {"query": "mejores cafeterías en Seattle", "count": 10}
    )
    print(f"Resultados de la búsqueda: {response}")

if __name__ == "__main__":
    asyncio.run(main())

Este script:

• Carga tu clave de API de Brave Search desde .env.
• Usa fastmcp para conectarse al servidor MCP.
• Envía una consulta de búsqueda web a través de la herramienta brave_web_search.

Paso 2: Instalar fastmcp

Instala la biblioteca cliente MCP:

pip install fastmcp

Paso 3: Ejecutar el cliente

Con tu entorno virtual activo:

python brave_mcp_client.py

Si todo va bien, el servidor MCP se inicia, consulta la API de Brave Search y imprime resultados como una lista JSON de cafeterías. ¡Obtuve una deliciosa lista de cafés en Seattle en segundos! Si ves errores, verifica:

• Clave de API: Asegúrate de que sea válida en .env o en la configuración.
• Registros: En Claude Desktop, ve a Configuraciones > Desarrollador para ver los registros en %UserProfile%\AppData\Roaming\Claude\Logs\ (Windows) o ~/Library/Application Support/Claude/Logs/ (Mac).
• Ruta de Node.js: Usuarios de Windows, verifica la ruta command en la configuración.

Integrando la API de Brave Search con Claude Desktop

Para usar tu servidor MCP con Claude Desktop:

1. Instala Claude Desktop: Descárgalo desde el sitio oficial de Anthropic e instálalo.
2. Agrega la configuración: Asegúrate de que claude_desktop_config.json esté en la carpeta correcta (ver arriba).
3. Reinicia Claude: Cierra completamente (Command+Q en Mac) y vuelve a abrirlo.
4. Prueba una consulta: En el chat de Claude, escribe: “Busca en la web las mejores cafeterías en Seattle.” Claude pedirá permiso para usar el servidor MCP, y luego mostrará los resultados.

Deberías ver que Claude registra “Realizando una solicitud de herramienta: brave_web_search” y obtiene resultados a través de la API de Brave Search. ¡Mi prueba mostró increíbles lugares de café sin ningún problema!

Para otros IDEs impulsados por IA como Codium/Windsurf, VS Code y Cursor. Al reutilizar la misma configuración de API de Brave Search, puedes permitir que estas herramientas realicen búsquedas web a través del servidor MCP, permitiendo que los asistentes de IA obtengan datos en tiempo real directamente dentro de la interfaz de chat de cada IDE. El proceso es similar e implica pegar la configuración existente en la configuración MCP correspondiente para cada IDE, con ajustes menores para los usuarios de Windows para asegurar las rutas correctas de Node.js como se mencionó anteriormente.

Y para guías más detalladas sobre cómo configurar servidores MCP en diferentes entornos, visita apidog.com/blog, donde encontrarás recursos útiles para integrar sin problemas la API de Brave Search (y muchos otros servidores MCP) con tus herramientas de codificación preferidas.

¿Por qué usar la API de Brave Search con un servidor MCP?

Esta combinación es increíble porque:

• Datos en tiempo real: La API de Brave Search obtiene resultados web y locales frescos, a diferencia del conocimiento estático de los LLM.
• Enfoque en la privacidad: El enfoque de privacidad de Brave mantiene las búsquedas seguras.
• Fácil integración: La configuración del servidor MCP es plug-and-play con herramientas como Claude.

En comparación con el servidor MCP de Perplexity, la API de Brave ofrece búsqueda local y filtrado flexible, lo que la convierte en una opción destacada.

Consejos profesionales para el éxito del MCP de Brave Search

• Valida la configuración: Usa un linter de JSON para detectar errores tipográficos en claude_desktop_config.json.
• Revisa los registros: Depura con la configuración de desarrollador de Claude si el servidor falla.
• Prueba la búsqueda local: Consulta “restaurantes cerca de mí” para probar el retroceso local de la API de Brave Search.
• Explora más servidores: Revisa mcp.so para servidores como Firecrawl (raspado web) o GitHub.

Concluyendo: Tu aventura con el MCP de Brave Search comienza

¡Felicidades! Has construido un servidor MCP que aprovecha la API de Brave Search para convertir tu IA en una superestrella de las búsquedas. Desde configurar Node.js hasta consultar cafeterías con Claude, ahora estás listo para explorar la web con IA. Prueba a buscar noticias, servicios locales o incluso temas específicos la próxima vez. La lista de servidores MCP tiene más herramientas para experimentar, y la comunidad de MCP de Claude en claudemcp.com está llena de ideas. ¿Cuál es tu próxima consulta? ¿Últimas tendencias tecnológicas? ¿Un restaurante escondido? Y no olvides pasar por apidog.com para ese toque extra de API.