Firebolt

Conecte seu LLM ao Firebolt Data Warehouse para consulta e análise de dados.

GitHub

Experimente este MCPPatrocinado

Documentação

MCP Server

Uma implementação do Model Context Protocol que conecta seu LLM ao Firebolt Data Warehouse

Principais Recursos | Como Usar | Conectando Seu LLM | Arquitetura | Desenvolvimento

Principais Recursos

Integração com LLM e Firebolt

Conecte seus assistentes de IA diretamente ao seu data warehouse
Permita que agentes de IA consultem dados e gerem insights de forma autônoma
Forneça aos LLMs conhecimento profundo sobre SQL do Firebolt, recursos e documentação

Execução de Consultas SQL

Suporte a múltiplos tipos de consulta e modos de execução
Acesso direto aos bancos de dados do Firebolt

Acesso à Documentação

Conceda aos LLMs acesso à documentação abrangente do Firebolt, referência SQL, listas de funções e muito mais

Gerenciamento de Contas

Autenticação perfeita com contas de serviço do Firebolt
Conexão a diferentes engines e workspaces

Suporte Multiplataforma

Funciona em qualquer lugar onde binários Go sejam suportados
Imagem Docker oficial disponível para implantação fácil

Como Usar

Antes de começar, certifique-se de ter:

Uma conta de serviço do Firebolt com um client ID e client secret.
Uma URL de instância do Firebolt Core.

Instalando o MCP Server

Você pode executar o Firebolt MCP Server via Docker ou baixando o binário.

Opção 1: Executar com 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

Opção 2: Executar o Binário

# 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 Seu LLM

Depois que o MCP Server estiver instalado, você pode conectar vários clientes LLM. Escolha seu cliente abaixo.

Cursor

Instale o servidor MCP do Firebolt no Cursor com um clique. Você precisará definir suas credenciais em Cursor Settings > Tools & MCP (edite o servidor adicionado ou mcp.json).

Firebolt Cloud (conta de serviço):

Firebolt Core (local ou auto-hospedado):

[!IMPORTANT] O Cursor ainda não suporta recursos MCP. Este servidor MCP usa recursos intensivamente, portanto não funcionará no Cursor a menos que o uso de recursos esteja desabilitado. Os botões acima já definem FIREBOLT_MCP_DISABLE_RESOURCES=true para você. Se você configurar manualmente, deverá definir essa variável de ambiente.

VS Code (Copilot Chat)

Para integrar o MCP com o Copilot Chat no VS Code, consulte o guia oficial: Extending Copilot Chat with the Model Context Protocol.

Adicione o servidor MCP do Firebolt à sua configuração MCP (por exemplo, via Command Palette > MCP: Open User Configuration). Exemplo para Firebolt Cloud com 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"
      }
    }
  }
}

Substitua your-client-id e your-client-secret pelas credenciais da sua conta de serviço do Firebolt.

Claude Desktop

Para integrar com o Claude Desktop usando Docker:

Abra o menu do Claude e selecione Settings….
Navegue até Developer > Edit Config.

Atualize o arquivo de configuração (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 o binário em vez do 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 ao Firebolt Core

Se você estiver usando Firebolt Core, pode se conectar fornecendo a URL do Core em vez das credenciais da conta de serviço.

Para usar o Firebolt Core com 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"
      }
    }
  }
}

Salve a configuração e reinicie o Claude Desktop.

Mais detalhes: Claude MCP Quickstart Guide

Configuração manual (outros clientes MCP)

Para qualquer cliente MCP que use uma configuração JSON (por exemplo, mcpServers), você pode adicionar o servidor Firebolt com a seguinte configuração 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, use FIREBOLT_MCP_CORE_URL (por exemplo, http://localhost:3473) em env e passe -e FIREBOLT_MCP_CORE_URL em args em vez do client ID/secret. Para o Cursor, também defina FIREBOLT_MCP_DISABLE_RESOURCES=true em env e em args.

Usando Transporte SSE

Por padrão, o MCP Server usa STDIO como mecanismo de transporte.
No entanto, Server-Sent Events (SSE) também são suportados e exigem configuração adicional.

Para habilitar SSE, defina o sinalizador de CLI --transport (ou a variável de ambiente FIREBOLT_MCP_TRANSPORT) como sse.

Opcionalmente, você pode especificar o endereço no qual o servidor deve escutar definindo o sinalizador de CLI --transport-sse-listen-address (ou a variável de ambiente FIREBOLT_MCP_TRANSPORT_SSE_LISTEN_ADDRESS).

Exigindo que LLMs apresentem prova de leitura de documentação antes de conectar

Para fornecer contexto mais amplo aos LLMs antes de conectar ao Firebolt e executar consultas, por padrão a ferramenta firebolt_connect exige que o LLM apresente uma prova de leitura da documentação do Firebolt (consultando a ferramenta firebolt_docs_overview).

Embora isso forneça um bom ponto de partida para LLMs, garantindo que eles tenham contexto completo da documentação do Firebolt, ao mesmo tempo isso pode levar a respostas mais lentas e maior consumo de tokens.

Para desabilitar esse requisito, defina o sinalizador bool de CLI --skip-docs-proof (ou a variável de ambiente FIREBOLT_MCP_SKIP_DOCS_PROOF) como false.

Arquitetura

O Firebolt MCP Server implementa o Model Context Protocol, fornecendo:

Ferramentas - Capacidades específicas de tarefas fornecidas ao LLM:
- firebolt_docs_overview: Acessar visão geral básica da documentação do Firebolt
- firebolt_connect: Estabelecer conexões com engines e bancos de dados do Firebolt
- firebolt_query: Executar consultas SQL no Firebolt
- firebolt_docs_search: Pesquisar na documentação do Firebolt por qualquer detalhe
Recursos - Dados que podem ser referenciados pelo LLM:
- Artigos de documentação
- Listas de Contas, Bancos de Dados, Engines
Prompts - Instruções predefinidas para o LLM:
- Firebolt Expert: Instrui o modelo a atuar como especialista em Firebolt

Desenvolvimento

Para configurar o ambiente de desenvolvimento:

# 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