Servidor MCP de Firebolt | Awesome MCP Servers

MCP Server

Una implementación del Model Context Protocol que conecta tu LLM con Firebolt Data Warehouse

Características clave | Cómo usar | Conectando tu LLM | Arquitectura | Desarrollo

Características clave

Integración de LLM con Firebolt

Conecta tus asistentes de IA directamente a tu almacén de datos
Permite que los agentes de IA consulten datos de forma autónoma y generen información
Proporciona a los LLMs un conocimiento profundo de Firebolt SQL, características y documentación

Ejecución de consultas SQL

Soporte para múltiples tipos de consulta y modos de ejecución
Acceso directo a las bases de datos de Firebolt

Acceso a la documentación

Concede a los LLMs acceso a documentación completa de Firebolt, referencia SQL, listas de funciones y más

Gestión de cuentas

Autenticación sin interrupciones con cuentas de servicio de Firebolt
Conéctate a diferentes motores y espacios de trabajo

Soporte multiplataforma

Se ejecuta en cualquier lugar donde se admitan binarios de Go
Imagen oficial de Docker disponible para una fácil implementación

Cómo Usar

Antes de comenzar, asegúrate de tener uno de los siguientes:

Una cuenta de servicio de Firebolt con un ID de cliente y un secreto de cliente.
Una URL de instancia de Firebolt Core.

Instalando el servidor MCP

Puedes ejecutar el servidor MCP de Firebolt ya sea mediante Docker o descargando el binario.

Opción 1: Ejecutar con Docker

docker run \
  --rm \
  --network host \
  -e FIREBOLT_MCP_CLIENT_ID=your-client-id \
  -e FIREBOLT_MCP_CLIENT_SECRET=your-client-secret \
  ghcr.io/firebolt-db/mcp-server:0.6.0

Opción 2: Ejecutar el binario

# Download the binary for your OS from:
# https://github.com/firebolt-db/mcp-server/releases/tag/v0.6.0

./firebolt-mcp-server \
  --client-id your-client-id \
  --client-secret your-client-secret

Conectando tu LLM

Una vez que el servidor MCP esté instalado, puedes conectar varios clientes LLM. Elige tu cliente a continuación.

Cursor

Instala el servidor MCP de Firebolt en Cursor con un solo clic. Deberás configurar tus credenciales en Configuración de Cursor > Herramientas y MCP (edita el servidor agregado o mcp.json).

Firebolt Cloud (cuenta de servicio):

Firebolt Core (local o autoalojado):

[!IMPORTANTE] Cursor aún no admite recursos MCP. Este servidor MCP utiliza recursos intensivamente, por lo que no funcionará en Cursor a menos que se desactive el uso de recursos. Los botones anteriores ya establecen FIREBOLT_MCP_DISABLE_RESOURCES=true por ti. Si configuras manualmente, debes definir esta variable de entorno.

VS Code (Copilot Chat)

Para integrar MCP con Copilot Chat en VS Code, consulta la guía oficial: Extendiendo Copilot Chat con el Model Context Protocol.

Agrega el servidor MCP de Firebolt a tu configuración de MCP (por ejemplo, mediante la Paleta de comandos > MCP: Abrir configuración de usuario). Ejemplo para Firebolt Cloud con Docker:

{
  "mcpServers": {
    "firebolt": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "--network", "host",
        "-e", "FIREBOLT_MCP_CLIENT_ID",
        "-e", "FIREBOLT_MCP_CLIENT_SECRET",
        "ghcr.io/firebolt-db/mcp-server:latest"
      ],
      "env": {
        "FIREBOLT_MCP_CLIENT_ID": "your-client-id",
        "FIREBOLT_MCP_CLIENT_SECRET": "your-client-secret"
      }
    }
  }
}

Reemplaza your-client-id y your-client-secret con tus credenciales de cuenta de servicio de Firebolt.

Claude Desktop

Para integrarlo con Claude Desktop usando Docker:

Abre el menú de Claude y selecciona Configuración….
Ve a Desarrollador > Editar configuración.

Actualiza el archivo de configuración (claude_desktop_config.json) para incluir:

{
  "mcpServers": {
    "firebolt": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "--network", "host",
        "-e", "FIREBOLT_MCP_CLIENT_ID",
        "-e", "FIREBOLT_MCP_CLIENT_SECRET",
        "ghcr.io/firebolt-db/mcp-server:0.6.0"
      ],
      "env": {
        "FIREBOLT_MCP_CLIENT_ID": "your-client-id",
        "FIREBOLT_MCP_CLIENT_SECRET": "your-client-secret"
      }
    }
  }
}

Para usar el binario en lugar de Docker:

{
  "mcpServers": {
    "firebolt": {
      "command": "/path/to/firebolt-mcp-server",
      "env": {
        "FIREBOLT_MCP_CLIENT_ID": "your-client-id",
        "FIREBOLT_MCP_CLIENT_SECRET": "your-client-secret"
      }
    }
  }
}

Conectando a Firebolt Core

Si estás utilizando Firebolt Core, puedes conectarte proporcionando la URL de Core en lugar de las credenciales de la cuenta de servicio.

Para usar Firebolt Core con Claude Desktop:

{
  "mcpServers": {
    "firebolt": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "--network", "host",
        "-e", "FIREBOLT_MCP_CORE_URL",
        "ghcr.io/firebolt-db/mcp-server:0.6.0"
      ],
      "env": {
        "FIREBOLT_MCP_CORE_URL": "http://localhost:3473"
      }
    }
  }
}

Guarda la configuración y reinicia Claude Desktop.

Más detalles: Guía de inicio rápido de Claude MCP

Configuración manual (otros clientes MCP)

Para cualquier cliente MCP que use una configuración JSON (por ejemplo, mcpServers), puedes agregar el servidor de Firebolt con la siguiente configuración canónica. Firebolt Cloud (Docker):

{
  "mcpServers": {
    "firebolt": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "--network", "host",
        "-e", "FIREBOLT_MCP_CLIENT_ID",
        "-e", "FIREBOLT_MCP_CLIENT_SECRET",
        "ghcr.io/firebolt-db/mcp-server:latest"
      ],
      "env": {
        "FIREBOLT_MCP_CLIENT_ID": "your-client-id",
        "FIREBOLT_MCP_CLIENT_SECRET": "your-client-secret"
      }
    }
  }
}

Para Firebolt Core, usa FIREBOLT_MCP_CORE_URL (por ejemplo, http://localhost:3473) en env y pasa -e FIREBOLT_MCP_CORE_URL en args en lugar del ID de cliente/secreto. Para Cursor, también establece FIREBOLT_MCP_DISABLE_RESOURCES=true en env y en args.

Usando transporte SSE

Por defecto, el servidor MCP utiliza STDIO como mecanismo de transporte.
Sin embargo, también se admiten eventos enviados por el servidor (SSE) y requieren configuración adicional.

Para habilitar SSE, establece el indicador de CLI --transport (o la variable de entorno FIREBOLT_MCP_TRANSPORT) en sse.

Opcionalmente, puedes especificar la dirección en la que el servidor debe escuchar configurando el indicador de CLI --transport-sse-listen-address (o la variable de entorno FIREBOLT_MCP_TRANSPORT_SSE_LISTEN_ADDRESS).

Exigir que los LLMs presenten prueba de lectura de documentación antes de conectarse

Para proporcionar un contexto más amplio a los LLMs antes de conectarse a Firebolt y ejecutar consultas, por defecto la herramienta firebolt_connect requiere que el LLM presente una prueba de lectura de la documentación de Firebolt (consultando la herramienta firebolt_docs_overview).

Si bien esto proporciona un buen punto de partida para que el LLM tenga todo el contexto de la documentación de Firebolt, al mismo tiempo puede generar respuestas más lentas y un mayor consumo de tokens.

Para deshabilitar este requisito, establece el indicador booleano de CLI --skip-docs-proof (o la variable de entorno FIREBOLT_MCP_SKIP_DOCS_PROOF) en false.

Arquitectura

El servidor MCP de Firebolt implementa el Model Context Protocol, proporcionando:

Herramientas - Capacidades específicas de tareas proporcionadas al LLM:
- firebolt_docs_overview: Accede a una descripción general básica de la documentación de Firebolt
- firebolt_connect: Establece conexiones con motores y bases de datos de Firebolt
- firebolt_query: Ejecuta consultas SQL contra Firebolt
- firebolt_docs_search: Busca en la documentación de Firebolt cualquier detalle
Recursos - Datos a los que el LLM puede hacer referencia:
- Artículos de documentación
- Listas de cuentas, bases de datos, motores
Indicaciones - Instrucciones predefinidas para el LLM:
- Experto en Firebolt: Indica al modelo que actúe como especialista en Firebolt

Desarrollo

Para configurar el entorno de desarrollo:

# Clone this repository
git clone https://github.com/firebolt-db/mcp-server.git

# Go into the repository
cd mcp-server

# Install Task (if you don't have it already)
go install github.com/go-task/task/v3/cmd/task@latest

# Update Go dependencies
task mod

# Build the application
task build

# Run the tests
task test

Firebolt

Documentación