Faucet

Transforme PostgreSQL, MySQL, MariaDB, SQL Server, Oracle, SQLite ou Snowflake em ferramentas MCP e uma API REST, com chaves de API e acesso baseado em funções por tabela.

GitHub

115

Experimente este MCPPatrocinado

Documentação

Faucet: servidor REST API e MCP para qualquer banco de dados SQL

Transforme qualquer banco de dados SQL em uma API REST segura e um servidor MCP.
Um único binário. Um único comando.

Faucet é um binário Go único de código aberto (MIT) que transforma PostgreSQL, MySQL, MariaDB, SQL Server, Oracle, Snowflake ou SQLite em uma API REST e um servidor MCP para agentes de IA, com controle de acesso baseado em funções (RBAC), OpenAPI 3.1 e uma interface de administração integrada.

Endpoints, especificações OpenAPI e ferramentas MCP são gerados a partir do esquema do seu banco de dados em tempo de execução. Sem geração de código, sem ORM, sem código repetitivo.

Site · Documentação · Primeiros passos · Docker · Servidor MCP · Problemas

O que é o Faucet?

Faucet é um gateway de banco de dados para API REST — um servidor leve e auto-hospedado que se conecta aos seus bancos de dados SQL, inspeciona o esquema e gera uma API REST CRUD completa com autenticação, controle de acesso baseado em funções (RBAC) e documentação OpenAPI. Ele também expõe um servidor MCP em /mcp para que agentes de IA e criadores de aplicativos de IA (Claude, ChatGPT, Cursor, VS Code, Windsurf, Base44, Replit) possam consultar seus dados usando as mesmas funções e chaves de API.

Pense nele como uma alternativa de código aberto ao DreamFactory, PostgREST ou Hasura, com suporte a vários bancos de dados, interface de administração integrada e integração nativa com agentes de IA, tudo em um único binário. Veja como ele se compara.

Faucet admin UI listing connected PostgreSQL and SQLite databases

Casos de uso

Backend instantâneo para aplicativos — Evite escrever APIs CRUD manualmente. Aponte o Faucet para seu banco de dados e comece a construir seu frontend.
Acesso a dados por agentes de IA — Dê a Claude, GPT ou qualquer agente compatível com MCP acesso governado de leitura/escrita aos seus bancos de dados.
Ferramentas internas e painéis — Gere APIs para bancos de dados internos sem modificar a infraestrutura existente.
Modernização de bancos de dados legados — Coloque uma API REST na frente do SQL Server 2012, MySQL 5.7 ou PostgreSQL 9.6 sem alterações de código.
Agregação de vários bancos de dados — Conecte PostgreSQL, MySQL, SQL Server, Oracle e outros a uma única instância do Faucet e consulte todos por meio de uma única API.
Prototipagem rápida — Vá de um banco de dados vazio a uma API funcional em menos de 60 segundos.

Como funciona

┌──────────────┐       ┌───────────────────────────────────────┐       ┌──────────────┐
│ PostgreSQL   │       │              F A U C E T              │       │   REST API   │
│ MySQL        │──────▶│                                       │──────▶│   /api/v1/*  │
│ MariaDB      │  SQL  │  ┌─────────┐ ┌──────┐ ┌───────────┐   │       ├──────────────┤
│ SQL Server   │◀──────│  │ Schema  │ │ RBAC │ │  OpenAPI  │   │──────▶│  OpenAPI 3.1 │
│ Oracle       │       │  │ Intro-  │ │ Auth │ │ Generator │   │       │ /openapi.json│
│ Snowflake    │       │  │ spection│ │      │ │           │   │       ├──────────────┤
│ SQLite       │       │  └─────────┘ └──────┘ └───────────┘   │──────▶│  MCP Server  │
└──────────────┘       │                                       │       │  (AI Agents) │
                       │  ┌──────────────────────────────────┐ │       ├──────────────┤
                       │  │   Embedded Admin UI (Preact)     │ │──────▶│   Admin UI   │
                       │  └──────────────────────────────────┘ │       │  :8080/      │
                       └───────────────────────────────────────┘       └──────────────┘

Conecte qualquer banco de dados SQL → o Faucet inspeciona o esquema → Gera instantaneamente endpoints REST, documentos OpenAPI, ferramentas MCP e uma interface de administração — tudo protegido com chaves de API, autenticação JWT e permissões baseadas em funções.

Capturas de tela

Adding a PostgreSQL database in the Faucet admin UI with host, port, user and password fields
Conecte um banco de dados com host, porta, usuário e senha. O Faucet testa antes de salvar e informa o que corrigir.

Faucet schema page showing columns, keys and schema drift on a locked table
Navegue por tabelas, colunas, chaves e dados, e bloqueie seu contrato de API contra alterações de esquema que quebram a compatibilidade.

Faucet API explorer with a filtered query, JSON response and copy-as-curl
Crie requisições com filtros e paginação e copie-as como curl, JavaScript ou Python.

Faucet AI agents page with ready-made MCP configs for Claude Code, Cursor, VS Code and more
Configuração MCP pronta para copiar para Claude Code, Claude Desktop, Cursor, VS Code, Windsurf e ChatGPT.

Veja o guia da interface de administração para um tour por todas as páginas.

Principais recursos

Geração de API

API REST CRUD completa — GET, POST, PUT, PATCH, DELETE com filtragem, ordenação e paginação
Inspeção de esquema — Descobre tabelas, colunas, tipos e restrições em tempo de execução
DDL de esquema — Crie, altere e exclua tabelas via API
Chamadas de procedimentos armazenados — Execute procedimentos armazenados com parâmetros tipados
Filtros de consulta legíveis — (age > 21) AND (status = 'active')
Especificação OpenAPI 3.1 — Gerada automaticamente a partir do esquema do banco de dados em tempo real em /openapi.json

Segurança e controle de acesso

Autenticação por chave de API — Chaves com hash SHA-256 com atribuição de função por chave
Autenticação JWT — Tokens assinados com HMAC-SHA256 para sessões de administrador
Controle de acesso baseado em funções (RBAC) — Permissões de verbo por tabela (GET, POST, PUT, PATCH, DELETE)
Filtros de segurança em nível de linha — Expressões de filtro são armazenadas por regra de acesso e retornadas pela API; aplicá-las às consultas está planejado e ainda não é aplicado
Bloqueio de contrato de esquema — Bloqueie seu contrato de API contra alterações silenciosas de esquema que quebram a compatibilidade com três modos (nenhum, automático, estrito), detecção de desvios e gerenciamento via CLI

Integração com agentes de IA (MCP)

Servidor MCP integrado — 8 ferramentas + 2 recursos para o Model Context Protocol, servidos em /mcp na mesma porta da API REST
Funciona com suas ferramentas de IA — Configurações prontas para copiar para Claude Code, Claude Desktop, Cursor, VS Code e Windsurf; ChatGPT via uma Ação Custom GPT em /openapi.json
Transporte HTTP streamable + stdio — Autenticado por chave de API pela rede, ou stdio na sua própria máquina
Consultas de IA governadas — Agentes de IA respeitam as mesmas regras de RBAC que os clientes de API

Experiência do desenvolvedor

Binário único — Zero dependências externas, multiplataforma (Linux, macOS, Windows)
Interface de administração integrada — conecte bancos de dados com host, porta, usuário e senha (sem strings de conexão), teste antes de salvar, navegue por esquemas e dados, crie funções e chaves e copie configurações MCP prontas para Claude, Cursor, VS Code e outros. Funciona offline; temas claro e escuro
Armazenamento de configuração SQLite — Toda a configuração armazenada localmente, sem necessidade de banco de dados externo
npm + Homebrew + Docker — Instale em segundos em qualquer plataforma (npx @faucetdb/faucet)
Endpoints de saúde — /healthz e /readyz para sondagens no estilo Kubernetes

Bancos de dados suportados

Banco de dados	Versões	Variantes em nuvem	Tutorial
PostgreSQL	9.6 – 17	Amazon RDS, Aurora, Supabase, Neon, Azure Database	Guia
MySQL	5.7 – 9.x	Amazon RDS, Aurora MySQL, PlanetScale, Azure MySQL	Guia
MariaDB	10.2 – 11.x	Via driver MySQL	Guia MySQL
SQL Server	2012 – 2022	Azure SQL Database, Amazon RDS	Guia
Oracle	12c – 26ai	Oracle Cloud (OCI), Amazon RDS, Azure	Guia
Snowflake	Atual	AWS, Azure, GCP	Guia
SQLite	3.35+	Arquivo local, em memória	Guia

Detalhes de conectores, opções de SSL e notas sobre drivers: Conectores de banco de dados.

Início rápido em 60 segundos

Instalação

npm (Node.js 18+):

npx @faucetdb/faucet serve

Homebrew (macOS / Linux):

brew install faucetdb/tap/faucet

Docker:

docker run -p 8080:8080 -v faucet-data:/data faucetdb/faucet

Go:

go install github.com/faucetdb/faucet/cmd/faucet@latest

Download do binário: Veja GitHub Releases para binários pré-compilados (Linux, macOS, Windows).

Execução

faucet serve

Abra http://localhost:8080. O assistente de configuração cria sua conta de administrador e conecta seu primeiro banco de dados: escolha o mecanismo, insira host, porta, nome de usuário e senha, clique em Testar conexão e salve. Cada tabela recebe endpoints REST em /api/v1/<name>/_table/<table> e ferramentas MCP imediatamente. Em seguida, crie uma função na página Funções e uma chave de API na página Chaves de API, que fornece um comando curl pronto para executar e um comando de configuração MCP que já contém a nova chave.

Prefere o terminal? Os mesmos passos com a CLI:

# Create an admin account and add a database (no connection string needed)
faucet admin create --email admin@example.com --password changeme123
faucet db add --name mydb --driver postgres \
  --host localhost --user app --password 's3cret@!' --database mydb

# Create a role that can read every database, then an API key bound to it
faucet role create --name default --verbs GET
faucet key create --role default

# Start the server (it loads databases on startup), then query your data
faucet serve
curl -H "X-API-Key: faucet_YOUR_KEY_HERE" "http://localhost:8080/api/v1/mydb/_table/users?limit=10"

--dsn ainda funciona se você já tiver uma string de conexão. Um servidor em execução detecta bancos de dados adicionados pela interface de administração ou API imediatamente; bancos de dados adicionados com faucet db add são carregados na próxima vez que o servidor iniciar.

Servidor MCP para agentes de IA

O Faucet inclui um servidor Model Context Protocol (MCP) integrado, para que agentes de IA como Claude, Cursor, VS Code Copilot e Windsurf possam consultar e modificar seus bancos de dados por meio de acesso governado e baseado em ferramentas.

faucet serve expõe o servidor MCP em http://localhost:8080/mcp (HTTP streamable), na mesma porta da API REST. Autentique com uma chave de API no cabeçalho X-API-Key. A função da chave controla quais bancos de dados e tabelas o agente pode ver e alterar, exatamente como na API REST.

A página Agentes de IA (MCP) na interface de administração gera cada configuração abaixo com sua chave preenchida. Substitua YOUR_API_KEY por uma chave da página Chaves de API ou faucet key create.

Claude Code

claude mcp add --transport http faucet http://localhost:8080/mcp \
  --header "X-API-Key: YOUR_API_KEY"

Cursor, VS Code, Windsurf

Cursor (~/.cursor/mcp.json ou .cursor/mcp.json):

{
  "mcpServers": {
    "faucet": {
      "url": "http://localhost:8080/mcp",
      "headers": { "X-API-Key": "YOUR_API_KEY" }
    }
  }
}

VS Code (.vscode/mcp.json, usado pelo Copilot Chat em modo agente):

{
  "servers": {
    "faucet": {
      "type": "http",
      "url": "http://localhost:8080/mcp",
      "headers": { "X-API-Key": "YOUR_API_KEY" }
    }
  }
}

Windsurf (~/.codeium/windsurf/mcp_config.json): igual ao Cursor, com serverUrl em vez de url.

Claude Desktop

O arquivo de configuração do Claude Desktop só inicia comandos locais, então use a ponte mcp-remote (requer Node.js) em claude_desktop_config.json:

{
  "mcpServers": {
    "faucet": {
      "command": "npx",
      "args": ["-y", "mcp-remote", "http://localhost:8080/mcp", "--header", "X-API-Key:YOUR_API_KEY"]
    }
  }
}

Para um servidor Faucet em outra máquina via http:// simples, adicione "--allow-http" aos argumentos. Veja examples/claude-desktop-config.json.

ChatGPT

Os conectores do ChatGPT fazem login com OAuth, que o Faucet não suporta. Use uma Ação Custom GPT em vez disso: exponha o Faucet via HTTPS, importe https://your-host/openapi.json e defina a autenticação como chave de API com o cabeçalho personalizado X-API-Key.

stdio local (apenas sua máquina)

Clientes MCP também podem iniciar o Faucet como um subprocesso. O modo stdio lê os bancos de dados configurados com faucet serve ou faucet db add (~/.faucet por padrão) e executa com direitos de administrador local: as funções não são aplicadas. Use apenas em sua própria máquina; para qualquer coisa compartilhada, use /mcp com uma chave de API.

{
  "mcpServers": {
    "faucet": {
      "command": "npx",
      "args": ["-y", "@faucetdb/faucet", "mcp"]
    }
  }
}

A mesma configuração está em examples/mcp-stdio-config.json. Se faucet estiver instalado (Homebrew, Go ou um binário de release), use "command": "faucet", "args": ["mcp"]. faucet mcp --transport http --port 3001 executa um servidor HTTP autônomo autenticado por chave de API em sua própria porta.

Guia completo, incluindo um teste com curl e a API OpenAI Responses: Documentação do servidor MCP.

Ferramentas MCP disponíveis

Ferramenta	Descrição
`faucet_list_services`	Lista todos os bancos de dados conectados
`faucet_list_tables`	Lista tabelas em um banco de dados
`faucet_describe_table`	Obtém nomes de colunas, tipos e restrições
`faucet_query`	Consulta registros com filtros, ordenação, paginação
`faucet_insert`	Insere novos registros
`faucet_update`	Atualiza registros existentes
`faucet_delete`	Exclui registros
`faucet_raw_sql`	Executa SQL bruto (somente administrador)

Referência da CLI

faucet serve                    # Start HTTP server (default :8080)
faucet db add NAME              # Add database connection
faucet db list                  # List configured databases
faucet db test NAME             # Test database connectivity
faucet db schema NAME           # Dump database schema
faucet db lock NAME             # Lock schema contract
faucet db unlock NAME           # Remove contract locks
faucet db diff NAME             # Show schema drift
faucet db promote NAME          # Promote contracts to match live schema
faucet key create               # Create API key
faucet key list                 # List API keys
faucet role create              # Create RBAC role (--verbs grants its first rule)
faucet role grant               # Add an access rule to a role
faucet role list                # List roles and their rules
faucet admin create             # Create admin account
faucet mcp                      # Start MCP server (stdio)
faucet openapi                  # Generate OpenAPI spec
faucet config set KEY VALUE     # Set configuration value
faucet version                  # Show version info

Regras de acesso (RBAC)

Uma função é uma lista de regras {service_name, component, verb_mask}. Uma chave de API herda as regras da função à qual está vinculada; cada requisição é verificada contra elas. Sessões JWT de administrador (o painel e /api/v1/system/*) ignoram o RBAC.

Bits de verbo — combine com OU bit a bit:

Verbo	Bit
GET	1
POST	2
PUT	4
PATCH	8
DELETE	16
all	31

Correspondência (sensível a maiúsculas/minúsculas — os padrões devem corresponder exatamente aos nomes de serviço e tabela como aparecem na URL):

service_name: * (qualquer serviço), um nome exato (mydb) ou um curinga de prefixo (prod_*)
component: * (qualquer coisa), um componente exato (_table/customers, _schema), um curinga de prefixo (_table/* — todas as tabelas e a listagem _table) ou um nome simples (customers, que corresponde a _table/customers, _schema/customers, ...)

Falha fechada. Uma função sem regras, uma regra com verb_mask 0 ou uma função inativa nega tudo com 403 e um envelope de erro que explica o motivo:

{"error":{"code":403,"message":"Role \"readonly\" does not permit POST on mydb/_table/orders",
          "context":{"role":"readonly","service":"mydb","component":"_table/orders","verb":"POST"}}}

Serviços sinalizados como read_only rejeitam toda solicitação que não seja GET, independentemente da função.

MCP. As ferramentas mapeiam os mesmos verbos: faucet_query = GET, faucet_insert = POST, faucet_update = PATCH, faucet_delete = DELETE, faucet_list_tables = GET em _table, faucet_describe_table = GET em _schema/{table}. faucet_raw_sql exige todos os cinco verbos em uma regra que corresponda ao componente _sql (por exemplo, *). faucet_list_services lista apenas os serviços que a função pode acessar. faucet mcp no modo stdio é executado com privilégios de administrador local; faucet mcp --transport http exige a mesma chave de API ou credenciais JWT do servidor principal.

Regras de concessão pela CLI:

faucet role create --name readonly --verbs GET                                        # GET on every service
faucet role grant --role readonly --service mydb --component "_table/orders" --verbs GET,POST

ou pela API de administração, que substitui toda a lista de regras:

curl -X PUT -H "Authorization: Bearer $JWT" -H "Content-Type: application/json" \
  http://localhost:8080/api/v1/system/role/1 -d '{
    "name": "readonly",
    "is_active": true,
    "access": [
      {"service_name": "*",    "component": "*",              "verb_mask": 1, "requestor_mask": 1, "filters": [], "filter_op": "AND"},
      {"service_name": "mydb", "component": "_table/orders",  "verb_mask": 3, "requestor_mask": 1, "filters": [], "filter_op": "AND"}
    ]
  }'

filters no nível de linha em uma regra são armazenados e retornados pela API, mas ainda não são aplicados às consultas.

Atualização. Antes desta correção, as regras de função eram armazenadas, mas nunca aplicadas a solicitações de chave de API. Funções criadas com faucet role create que nunca receberam regras agora serão negadas com 403 — conceda regras a elas com faucet role grant ou pela interface de administração. Funções criadas na interface de administração usam apenas GET por padrão em todos os serviços, portanto, chaves de API que antes gravavam dados por meio dessas funções agora precisam de POST/PUT/PATCH/DELETE concedidos explicitamente. Na inicialização, faucet serve registra um aviso para cada função que tem chaves de API ativas, mas negaria todas as solicitações (sem regras, apenas regras verb_mask: 0 ou inativas), junto com o comando faucet role grant que corrige isso.

O segredo de assinatura JWT do administrador não é mais um padrão embutido: quando auth.jwt_secret / FAUCET_AUTH_JWT_SECRET (alias FAUCET_JWT_SECRET) não está configurado, um segredo aleatório é gerado na primeira inicialização e persistido no diretório de dados. As sessões de administrador existentes são invalidadas pela atualização, a menos que o segredo já estivesse configurado — faça login novamente.

Rotas da API

GET  /healthz                                    # Liveness probe
GET  /readyz                                     # Readiness probe
GET  /openapi.json                               # OpenAPI 3.1 spec

POST   /api/v1/system/admin/session              # Admin login
GET    /api/v1/system/service                    # List services
POST   /api/v1/system/service                    # Create service
GET    /api/v1/system/role                       # List roles
POST   /api/v1/system/role                       # Create role
POST   /api/v1/system/api-key                    # Create API key

GET    /api/v1/{service}/_table                  # List tables
GET    /api/v1/{service}/_table/{table}          # Query records
POST   /api/v1/{service}/_table/{table}          # Insert records
PUT    /api/v1/{service}/_table/{table}          # Replace records
PATCH  /api/v1/{service}/_table/{table}          # Update records
DELETE /api/v1/{service}/_table/{table}          # Delete records

GET    /api/v1/{service}/_schema                 # List table schemas
POST   /api/v1/{service}/_schema                 # Create table
GET    /api/v1/{service}/_proc                   # List stored procedures
POST   /api/v1/{service}/_proc/{proc}            # Call procedure

Parâmetros de consulta

Parâmetro	Exemplo	Descrição
`filter`	`(age > 21) AND (name LIKE 'A%')`	Sintaxe de filtro no estilo SQL com parametrização segura
`order`	`created_at DESC, name ASC`	Ordem de classificação
`limit`	`25`	Máximo de registros a retornar
`offset`	`50`	Pular N registros para paginação
`fields`	`id,name,email`	Selecionar colunas específicas
`ids`	`1,2,3`	Filtrar por valores de chave primária
`include_count`	`true`	Incluir contagem total de registros nos metadados da resposta

Faucet vs PostgREST vs Hasura vs DreamFactory vs Supabase

Uma breve comparação de como cada projeto é estruturado. Abrange apenas fatos que você pode verificar na documentação de cada projeto; se algo aqui estiver desatualizado, por favor abra um problema.

	Faucet	PostgREST	Hasura	DreamFactory	Supabase
API principal	REST + OpenAPI 3.1, além de um endpoint MCP integrado em `/mcp`	REST	GraphQL-first	REST	REST (via PostgREST), realtime, auth, storage
Bancos de dados	PostgreSQL, MySQL, MariaDB, SQL Server, Oracle, Snowflake, SQLite	PostgreSQL	PostgreSQL e outras fontes via conectores	Muitas fontes SQL e NoSQL	PostgreSQL
Interface de administração	Embutida no binário	Nenhuma	Console	Aplicativo web de administração	Studio
Como executar	Binário Go único, configuração em SQLite embutido	Binário único	Engine mais um banco de metadados Postgres (v2)	Aplicativo PHP/Laravel	Plataforma hospedada ou auto-hospedagem de uma pilha Docker de vários serviços
Licença	MIT	MIT	Apache 2.0 (repositório graphql-engine)	Apache 2.0 (edição de código aberto), edições pagas disponíveis	Apache 2.0

FAQ

O que é o Faucet? O Faucet é um binário Go único de código aberto (MIT) que transforma um banco de dados SQL em uma API REST e um servidor MCP para agentes de IA. Ele suporta PostgreSQL, MySQL, MariaDB, SQL Server, Oracle, Snowflake e SQLite, e inclui RBAC, uma especificação OpenAPI 3.1 e uma interface de administração integrada.

Quais bancos de dados o Faucet suporta? Sete: PostgreSQL, MySQL, MariaDB (através do driver MySQL), SQL Server, Oracle, Snowflake e SQLite. Veja Bancos de dados suportados para versões e tutoriais por banco.

Como conecto o Claude Code ou o Claude Desktop ao meu banco de dados? Execute faucet serve, conecte seu banco de dados na interface de administração, crie uma chave de API e execute claude mcp add --transport http faucet http://localhost:8080/mcp --header "X-API-Key: YOUR_API_KEY". O Claude Desktop usa a ponte mcp-remote; veja Claude Desktop.

Como conecto o Cursor, VS Code ou Windsurf? Adicione http://localhost:8080/mcp como um servidor MCP HTTP com um cabeçalho X-API-Key. Configurações copiáveis estão em Cursor, VS Code, Windsurf e na página Agentes de IA (MCP) da interface de administração.

Como conecto o ChatGPT ao meu banco de dados? Exponha o Faucet via HTTPS, crie uma chave de API com uma função somente leitura e adicione uma Ação GPT personalizada que importe https://your-host/openapi.json com autenticação por chave de API (cabeçalho X-API-Key). Os conectores do ChatGPT exigem OAuth, que o Faucet não suporta.

Posso usar o Faucet com Base44, Replit ou outros construtores de aplicativos de IA? Sim. Exponha o Faucet via HTTPS e crie uma chave de API com escopo. Depois adicione https://your-host/mcp com um cabeçalho X-API-Key como um servidor MCP personalizado, ou chame a API REST (/api/v1/...) e a especificação OpenAPI (/openapi.json) do seu aplicativo.

O Faucet é auto-hospedado? Onde meus dados ficam? Sim. O Faucet roda onde você o executar (seu laptop, um servidor ao lado de um banco on-premise, um contêiner) e fala diretamente com seu banco de dados; as linhas não são copiadas para nenhum lugar. Sua própria configuração (conexões, funções, chaves de API, contas de administrador) é armazenada em um arquivo SQLite embutido no diretório de dados (~/.faucet por padrão, /data no Docker). A telemetria anônima de uso é descrita, com instruções para desativá-la, em TELEMETRY.md.

O Faucet é gratuito? Sim. O Faucet é de código aberto sob a licença MIT, sem níveis pagos para funcionalidades principais.

Como o Faucet é diferente do PostgREST? O PostgREST suporta apenas PostgreSQL. O Faucet suporta 7 bancos de dados (PostgreSQL, MySQL, MariaDB, SQL Server, Oracle, Snowflake, SQLite), inclui uma interface de administração integrada e fornece suporte MCP nativo para agentes de IA, tudo em um único binário.

Como o Faucet é diferente do Hasura? O Hasura é GraphQL-first. O Faucet gera APIs REST com uma especificação OpenAPI 3.1 (não GraphQL), roda como um binário único que mantém sua configuração em um arquivo SQLite embutido e inclui um servidor MCP integrado para agentes de IA.

Como o Faucet é diferente do DreamFactory? O DreamFactory é um aplicativo PHP/Laravel que roda em uma pilha de servidor web com PHP. O Faucet é um binário Go único sem dependências de runtime. O Faucet é totalmente de código aberto sob a licença MIT com todos os recursos incluídos, sem níveis pagos para funcionalidades principais.

Como o Faucet é diferente do Supabase? O Supabase é uma plataforma PostgreSQL (banco de dados, auth, storage, realtime) que você usa hospedada ou auto-hospeda como um conjunto de serviços. O Faucet não hospeda seus dados: ele coloca uma API REST e um servidor MCP na frente de um banco de dados que você já tem, incluindo MySQL, SQL Server, Oracle, Snowflake e SQLite.

O Faucet suporta GraphQL? Atualmente não. O Faucet gera APIs REST e especificações OpenAPI 3.1. O suporte a GraphQL pode ser adicionado no futuro.

O Faucet está pronto para produção? O Faucet está em desenvolvimento ativo. É adequado para ferramentas internas, prototipagem e integração com agentes de IA. Verifique a página de versões para a versão mais recente.

Agentes de IA podem gravar dados através do Faucet? Sim. As ferramentas MCP incluem faucet_insert, faucet_update e faucet_delete. Todas as operações respeitam as funções RBAC, então você pode dar aos agentes de IA acesso somente leitura ou leitura/gravação por tabela. SQL bruto fica desativado, a menos que você o permita para um serviço e conceda todos os verbos.

O Faucet exige um banco de dados separado para configuração? Não. O Faucet usa um banco de dados SQLite embutido para toda a configuração, credenciais, funções e chaves de API. Tudo é armazenado localmente em um único arquivo.

Compilando a partir do código-fonte

git clone https://github.com/faucetdb/faucet.git
cd faucet
make build      # Builds UI + Go binary
make test       # Runs all tests
make dev        # Dev mode with hot reload

Pilha de tecnologia

Go 1.25+ — Roteador Chi, sqlx, CLI Cobra/Viper
Preact + Vite + Tailwind — Interface de administração embutida
SQLite (Go puro, sem CGO) — Armazenamento de configuração
MCP (Model Context Protocol) — Integração com agentes de IA

Documentação

A documentação completa está em wiki.faucetdb.ai:

Começando: instale, conecte um banco de dados, faça sua primeira solicitação
Guia da interface de administração: um tour por cada página
Servidor MCP: conecte Claude, Cursor, VS Code, Windsurf e ChatGPT
Funções e chaves de API (RBAC)
Sintaxe de filtro
Referência da API
Referência da CLI
Bloqueio de esquema
Implantação: Docker, Kubernetes, systemd, proxies reversos, checklist de produção
Conectores de banco de dados e tutoriais para PostgreSQL, MySQL / MariaDB, SQL Server, Oracle, Snowflake e SQLite
Arquitetura
Guia para LLMs: uma referência compacta escrita para assistentes de codificação de IA

Contribuindo

Contribuições são bem-vindas! Consulte CONTRIBUTING.md para diretrizes, ou abra um problema para relatar bugs e solicitar recursos.

Licença

MIT — gratuito para uso comercial e pessoal.

Faucet

Documentação

Faucet: servidor REST API e MCP para qualquer banco de dados SQL

Transforme qualquer banco de dados SQL em uma API REST segura e um servidor MCP.Um único binário. Um único comando.

O que é o Faucet?

Casos de uso

Como funciona

Capturas de tela

Principais recursos

Geração de API

Segurança e controle de acesso

Integração com agentes de IA (MCP)

Experiência do desenvolvedor

Bancos de dados suportados

Início rápido em 60 segundos

Instalação

Execução

Servidor MCP para agentes de IA

Claude Code

Cursor, VS Code, Windsurf

Claude Desktop

ChatGPT

stdio local (apenas sua máquina)

Ferramentas MCP disponíveis

Referência da CLI

Regras de acesso (RBAC)

Rotas da API

Parâmetros de consulta

Faucet vs PostgREST vs Hasura vs DreamFactory vs Supabase

FAQ

Compilando a partir do código-fonte

Pilha de tecnologia

Documentação

Contribuindo

Licença

Transforme qualquer banco de dados SQL em uma API REST segura e um servidor MCP.
Um único binário. Um único comando.