Faucet

Convierte PostgreSQL, MySQL, MariaDB, SQL Server, Oracle, SQLite o Snowflake en herramientas MCP y una API REST, con claves API y acceso basado en roles por tabla.

GitHub

115

Prueba este MCPPatrocinado

Documentación

Faucet: servidor REST API y MCP para cualquier base de datos SQL

Convierte cualquier base de datos SQL en un servidor REST API y MCP seguro.
Un solo binario. Un solo comando.

Faucet es un binario único de Go de código abierto (MIT) que convierte PostgreSQL, MySQL, MariaDB, SQL Server, Oracle, Snowflake o SQLite en una API REST y un servidor MCP para agentes de IA, con control de acceso basado en roles (RBAC), OpenAPI 3.1 y una interfaz de administración integrada.

Los endpoints, las especificaciones OpenAPI y las herramientas MCP se generan a partir del esquema de tu base de datos en tiempo de ejecución. Sin generación de código, sin ORM, sin código repetitivo.

Sitio web · Documentación · Primeros pasos · Docker · Servidor MCP · Problemas

¿Qué es Faucet?

Faucet es una puerta de enlace de base de datos a API REST: un servidor ligero y autoalojado que se conecta a tus bases de datos SQL, inspecciona el esquema y genera una API REST CRUD completa con autenticación, control de acceso basado en roles (RBAC) y documentación OpenAPI. También expone un servidor MCP en /mcp para que los agentes de IA y los creadores de aplicaciones de IA (Claude, ChatGPT, Cursor, VS Code, Windsurf, Base44, Replit) puedan consultar tus datos a través de los mismos roles y claves de API.

Piénsalo como una alternativa de código abierto a DreamFactory, PostgREST o Hasura, con soporte para múltiples bases de datos, una interfaz de administración integrada e integración nativa con agentes de IA, todo en un solo binario. Consulta cómo se compara.

Faucet admin UI listing connected PostgreSQL and SQLite databases

Casos de uso

Backend instantáneo para aplicaciones: evita escribir APIs CRUD a mano. Apunta Faucet a tu base de datos y comienza a construir tu frontend.
Acceso a datos para agentes de IA: brinda a Claude, GPT o cualquier agente compatible con MCP un acceso gobernado de lectura/escritura a tus bases de datos.
Herramientas internas y paneles: genera APIs para bases de datos internas sin modificar la infraestructura existente.
Modernización de bases de datos heredadas: coloca una API REST frente a SQL Server 2012, MySQL 5.7 o PostgreSQL 9.6 sin cambios de código.
Agregación de múltiples bases de datos: conecta PostgreSQL, MySQL, SQL Server, Oracle y más a una sola instancia de Faucet y consúltalos todos a través de una sola API.
Prototipado rápido: pasa de una base de datos vacía a una API funcional en menos de 60 segundos.

Cómo 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/      │
                       └───────────────────────────────────────┘       └──────────────┘

Conecta cualquier base de datos SQL → Faucet inspecciona el esquema → Genera instantáneamente endpoints REST, documentos OpenAPI, herramientas MCP y una interfaz de administración, todo protegido con claves de API, autenticación JWT y permisos basados en roles.

Capturas de pantalla

Adding a PostgreSQL database in the Faucet admin UI with host, port, user and password fields
Conecta una base de datos con host, puerto, usuario y contraseña. Faucet la prueba antes de guardarla y te dice qué corregir.

Faucet schema page showing columns, keys and schema drift on a locked table
Explora tablas, columnas, claves y datos, y bloquea tu contrato de API contra cambios de esquema que rompan la compatibilidad.

Faucet API explorer with a filtered query, JSON response and copy-as-curl
Construye solicitudes con filtros y paginación, luego cópialas como curl, JavaScript o Python.

Faucet AI agents page with ready-made MCP configs for Claude Code, Cursor, VS Code and more
Configuración MCP lista para copiar para Claude Code, Claude Desktop, Cursor, VS Code, Windsurf y ChatGPT.

Consulta la guía de la interfaz de administración para un recorrido por cada página.

Características principales

Generación de API

API REST CRUD completa: GET, POST, PUT, PATCH, DELETE con filtrado, ordenamiento y paginación
Inspección de esquema: descubre tablas, columnas, tipos y restricciones en tiempo de ejecución
DDL de esquema: crea, modifica y elimina tablas a través de la API
Llamadas a procedimientos almacenados: ejecuta procedimientos almacenados con parámetros tipados
Filtros de consulta legibles: (age > 21) AND (status = 'active')
Especificación OpenAPI 3.1: generada automáticamente desde el esquema de la base de datos en vivo en /openapi.json

Seguridad y control de acceso

Autenticación con clave de API: claves con hash SHA-256 con asignación de roles por clave
Autenticación JWT: tokens firmados con HMAC-SHA256 para sesiones de administración
Control de acceso basado en roles (RBAC): permisos de verbo por tabla (GET, POST, PUT, PATCH, DELETE)
Filtros de seguridad a nivel de fila: las expresiones de filtro se almacenan por regla de acceso y las devuelve la API; aplicarlas a las consultas está planificado y aún no se aplica
Bloqueo de contrato de esquema: bloquea tu contrato de API contra cambios de esquema silenciosos que rompan la compatibilidad con tres modos (ninguno, automático, estricto), detección de desviaciones y gestión mediante CLI

Integración con agentes de IA (MCP)

Servidor MCP integrado: 8 herramientas + 2 recursos para el Protocolo de Contexto de Modelo, servidos en /mcp en el mismo puerto que la API REST
Funciona con tus herramientas de IA: configuraciones listas para copiar para Claude Code, Claude Desktop, Cursor, VS Code y Windsurf; ChatGPT a través de una acción de GPT personalizada en /openapi.json
Transporte HTTP transmisible + stdio: autenticado con clave de API a través de la red, o stdio en tu propia máquina
Consultas de IA gobernadas: los agentes de IA respetan las mismas reglas RBAC que los clientes de API

Experiencia de desarrollo

Binario único: cero dependencias externas, multiplataforma (Linux, macOS, Windows)
Interfaz de administración integrada: conecta bases de datos con host, puerto, usuario y contraseña (sin cadenas de conexión), prueba antes de guardar, explora esquemas y datos, crea roles y claves, y copia configuraciones MCP listas para Claude, Cursor, VS Code y más. Funciona sin conexión; temas claro y oscuro
Almacén de configuración SQLite: toda la configuración se almacena localmente, sin necesidad de base de datos externa
npm + Homebrew + Docker: instala en segundos en cualquier plataforma (npx @faucetdb/faucet)
Endpoints de salud: /healthz y /readyz para sondas estilo Kubernetes

Bases de datos compatibles

Base de datos	Versiones	Variantes en la nube	Tutorial
PostgreSQL	9.6 – 17	Amazon RDS, Aurora, Supabase, Neon, Azure Database	Guía
MySQL	5.7 – 9.x	Amazon RDS, Aurora MySQL, PlanetScale, Azure MySQL	Guía
MariaDB	10.2 – 11.x	Mediante controlador MySQL	Guía de MySQL
SQL Server	2012 – 2022	Azure SQL Database, Amazon RDS	Guía
Oracle	12c – 26ai	Oracle Cloud (OCI), Amazon RDS, Azure	Guía
Snowflake	Actual	AWS, Azure, GCP	Guía
SQLite	3.35+	Archivo local, en memoria	Guía

Detalles de conectores, opciones SSL y notas sobre controladores: Conectores de bases de datos.

Inicio rápido en 60 segundos

Instalación

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

Descarga de binario: consulta Versiones de GitHub para binarios precompilados (Linux, macOS, Windows).

Ejecución

faucet serve

Abre http://localhost:8080. El asistente de configuración crea tu cuenta de administrador y conecta tu primera base de datos: elige el motor, ingresa host, puerto, nombre de usuario y contraseña, haz clic en Probar conexión y guarda. Cada tabla recibe endpoints REST en /api/v1/<name>/_table/<table> y herramientas MCP de inmediato. Luego crea un rol en la página Roles y una clave de API en la página Claves de API, que te entrega un comando curl listo para ejecutar y un comando de configuración MCP que ya contienen la nueva clave.

¿Prefieres la terminal? Los mismos pasos con la 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 todavía funciona si ya tienes una cadena de conexión. Un servidor en ejecución detecta las bases de datos agregadas a través de la interfaz de administración o la API de inmediato; las bases de datos agregadas con faucet db add se cargan la próxima vez que se inicie el servidor.

Servidor MCP para agentes de IA

Faucet incluye un servidor Protocolo de Contexto de Modelo (MCP) integrado, para que agentes de IA como Claude, Cursor, VS Code Copilot y Windsurf puedan consultar y modificar tus bases de datos mediante acceso gobernado basado en herramientas.

faucet serve expone el servidor MCP en http://localhost:8080/mcp (HTTP transmisible), en el mismo puerto que la API REST. Autentícate con una clave de API en el encabezado X-API-Key. El rol de la clave controla qué bases de datos y tablas puede ver y cambiar el agente, exactamente igual que para la API REST.

La página Agentes de IA (MCP) en la interfaz de administración genera cada configuración a continuación con tu clave completada. Reemplaza YOUR_API_KEY con una clave de la página Claves de API o 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 o .cursor/mcp.json):

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

VS Code (.vscode/mcp.json, utilizado por Copilot Chat en 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 que Cursor, con serverUrl en lugar de url.

Claude Desktop

El archivo de configuración de Claude Desktop solo inicia comandos locales, así que usa el puente mcp-remote (requiere Node.js) en claude_desktop_config.json:

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

Para un servidor Faucet en otra máquina a través de http:// simple, agrega "--allow-http" a los argumentos. Consulta examples/claude-desktop-config.json.

ChatGPT

Los conectores de ChatGPT inician sesión con OAuth, que Faucet no admite. Usa una Acción de GPT personalizada en su lugar: expón Faucet a través de HTTPS, importa https://your-host/openapi.json y configura la autenticación con clave de API con el encabezado personalizado X-API-Key.

stdio local (solo tu máquina)

Los clientes MCP también pueden iniciar Faucet como subproceso. El modo stdio lee las bases de datos configuradas con faucet serve o faucet db add (~/.faucet por defecto) y se ejecuta con derechos de administrador local: los roles no se aplican. Úsalo solo en tu propia máquina; para cualquier cosa compartida, usa /mcp con una clave de API.

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

La misma configuración está en examples/mcp-stdio-config.json. Si faucet está instalado (Homebrew, Go o un binario de versión), usa "command": "faucet", "args": ["mcp"]. faucet mcp --transport http --port 3001 ejecuta un servidor HTTP independiente autenticado con clave de API en su propio puerto.

Guía completa, incluida una prueba con curl y la API de Respuestas de OpenAI: Documentación del servidor MCP.

Herramientas MCP disponibles

Herramienta	Descripción
`faucet_list_services`	Lista todas las bases de datos conectadas
`faucet_list_tables`	Lista las tablas de una base de datos
`faucet_describe_table`	Obtiene nombres de columnas, tipos y restricciones
`faucet_query`	Consulta registros con filtros, ordenamiento y paginación
`faucet_insert`	Inserta nuevos registros
`faucet_update`	Actualiza registros existentes
`faucet_delete`	Elimina registros
`faucet_raw_sql`	Ejecuta SQL sin procesar (solo administrador)

Referencia de 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

Reglas de acceso (RBAC)

Un rol es una lista de reglas {service_name, component, verb_mask}. Una clave de API hereda las reglas del rol al que está vinculada; cada solicitud se verifica contra ellas. Las sesiones JWT de administrador (el panel y /api/v1/system/*) omiten RBAC.

Bits de verbo: combina con OR bit a bit:

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

Coincidencia (distingue mayúsculas y minúsculas: los patrones deben coincidir exactamente con los nombres de servicio y tabla tal como aparecen en la URL):

service_name: * (cualquier servicio), un nombre exacto (mydb) o un comodín de prefijo (prod_*)
component: * (cualquier cosa), un componente exacto (_table/customers, _schema), un comodín de prefijo (_table/* — cada tabla y el listado de _table), o un nombre simple (customers, que coincide con _table/customers, _schema/customers, ...)

Cierre seguro. Un rol sin reglas, una regla con verb_mask 0, o un rol inactivo deniega todo con 403 y un envoltorio de error que explica el 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"}}}

Los servicios marcados con read_only rechazan toda solicitud que no sea GET, independientemente del rol.

MCP. Las herramientas se asignan a los mismos verbos: faucet_query = GET, faucet_insert = POST, faucet_update = PATCH, faucet_delete = DELETE, faucet_list_tables = GET en _table, faucet_describe_table = GET en _schema/{table}. faucet_raw_sql requiere los cinco verbos en una regla que coincida con el componente _sql (p. ej., *). faucet_list_services solo lista los servicios a los que el rol puede acceder. faucet mcp en modo stdio se ejecuta con privilegios de administrador local; faucet mcp --transport http requiere la misma clave de API o credenciales JWT que el servidor principal.

Reglas de concesión desde la 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

o mediante la API de administración, que reemplaza toda la lista de reglas:

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"}
    ]
  }'

El filters a nivel de fila en una regla se almacena y devuelve la API, pero aún no se aplica a las consultas.

Actualización. Antes de esta corrección, las reglas de rol se almacenaban pero nunca se aplicaban a las solicitudes de clave de API. Los roles creados con faucet role create a los que nunca se les dieron reglas ahora se denegarán con 403 — concédeles reglas con faucet role grant o la interfaz de administración. Los roles creados en la interfaz de administración tienen por defecto solo GET en todos los servicios, por lo que las claves de API que antes escribían datos a través de dichos roles ahora necesitan POST/PUT/PATCH/DELETE concedidos explícitamente. Al iniciar, faucet serve registra una advertencia para cada rol que tenga claves de API activas pero que denegaría todas las solicitudes (sin reglas, solo reglas verb_mask: 0, o inactivo), junto con el comando faucet role grant que lo corrige.

El secreto de firma JWT de administración ya no es un valor predeterminado integrado: cuando auth.jwt_secret / FAUCET_AUTH_JWT_SECRET (alias FAUCET_JWT_SECRET) no está configurado, se genera un secreto aleatorio en el primer inicio y se persiste en el directorio de datos. Las sesiones de administración existentes se invalidan con la actualización a menos que el secreto ya estuviera configurado — vuelve a iniciar sesión.

Rutas de 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	Ejemplo	Descripción
`filter`	`(age > 21) AND (name LIKE 'A%')`	Sintaxis de filtro estilo SQL con parametrización segura
`order`	`created_at DESC, name ASC`	Orden de clasificación
`limit`	`25`	Máximo de registros a devolver
`offset`	`50`	Omitir N registros para paginación
`fields`	`id,name,email`	Seleccionar columnas específicas
`ids`	`1,2,3`	Filtrar por valores de clave primaria
`include_count`	`true`	Incluir el recuento total de registros en los metadatos de la respuesta

Faucet vs PostgREST vs Hasura vs DreamFactory vs Supabase

Una breve comparación de cómo está configurado cada proyecto. Cubre solo hechos que puedes verificar en la documentación de cada proyecto; si algo aquí está desactualizado, por favor abre un issue.

	Faucet	PostgREST	Hasura	DreamFactory	Supabase
API principal	REST + OpenAPI 3.1, además de un endpoint MCP integrado en `/mcp`	REST	GraphQL primero	REST	REST (a través de PostgREST), tiempo real, autenticación, almacenamiento
Bases de datos	PostgreSQL, MySQL, MariaDB, SQL Server, Oracle, Snowflake, SQLite	PostgreSQL	PostgreSQL más otras fuentes mediante conectores	Muchas fuentes SQL y NoSQL	PostgreSQL
Interfaz de administración	Integrada en el binario	Ninguna	Consola	Aplicación web de administración	Studio
Cómo se ejecuta	Un solo binario Go, configuración en SQLite integrado	Un solo binario	Motor más una base de datos de metadatos Postgres (v2)	Aplicación PHP/Laravel	Plataforma alojada, o autoalojamiento de un stack Docker de múltiples servicios
Licencia	MIT	MIT	Apache 2.0 (repositorio graphql-engine)	Apache 2.0 (edición de código abierto), ediciones de pago disponibles	Apache 2.0

Preguntas frecuentes

¿Qué es Faucet? Faucet es un binario Go único de código abierto (MIT) que convierte una base de datos SQL en una API REST y un servidor MCP para agentes de IA. Admite PostgreSQL, MySQL, MariaDB, SQL Server, Oracle, Snowflake y SQLite, e incluye RBAC, una especificación OpenAPI 3.1 y una interfaz de administración integrada.

¿Qué bases de datos admite Faucet? Siete: PostgreSQL, MySQL, MariaDB (a través del controlador MySQL), SQL Server, Oracle, Snowflake y SQLite. Consulta Bases de datos compatibles para ver versiones y tutoriales por base de datos.

¿Cómo conecto Claude Code o Claude Desktop a mi base de datos? Ejecuta faucet serve, conecta tu base de datos en la interfaz de administración, crea una clave de API y luego ejecuta claude mcp add --transport http faucet http://localhost:8080/mcp --header "X-API-Key: YOUR_API_KEY". Claude Desktop usa el puente mcp-remote; consulta Claude Desktop.

¿Cómo conecto Cursor, VS Code o Windsurf? Agrega http://localhost:8080/mcp como servidor MCP HTTP con un encabezado X-API-Key. Las configuraciones para copiar y pegar están en Cursor, VS Code, Windsurf y en la página Agentes de IA (MCP) de la interfaz de administración.

¿Cómo conecto ChatGPT a mi base de datos? Expón Faucet a través de HTTPS, crea una clave de API con un rol de solo lectura y agrega una acción de GPT personalizada que importe https://your-host/openapi.json con autenticación de clave de API (encabezado X-API-Key). Los conectores de ChatGPT necesitan OAuth, que Faucet no admite.

¿Puedo usar Faucet con Base44, Replit u otros creadores de aplicaciones de IA? Sí. Expón Faucet a través de HTTPS y crea una clave de API con alcance. Luego agrega https://your-host/mcp con un encabezado X-API-Key como servidor MCP personalizado, o llama a la API REST (/api/v1/...) y a la especificación OpenAPI (/openapi.json) desde tu aplicación.

¿Faucet se autoaloja? ¿Dónde viven mis datos? Sí. Faucet se ejecuta donde lo ejecutes (tu portátil, un servidor junto a una base de datos local, un contenedor) y habla directamente con tu base de datos; las filas no se copian a ningún lado. Su propia configuración (conexiones, roles, claves de API, cuentas de administrador) se almacena en un archivo SQLite integrado en el directorio de datos (~/.faucet por defecto, /data en Docker). La telemetría de uso anónimo se describe, con cómo desactivarla, en TELEMETRY.md.

¿Faucet es gratuito? Sí. Faucet es de código abierto bajo la licencia MIT, sin niveles de pago para la funcionalidad principal.

¿En qué se diferencia Faucet de PostgREST? PostgREST solo admite PostgreSQL. Faucet admite 7 bases de datos (PostgreSQL, MySQL, MariaDB, SQL Server, Oracle, Snowflake, SQLite), incluye una interfaz de administración integrada y proporciona soporte MCP nativo para agentes de IA, todo en un solo binario.

¿En qué se diferencia Faucet de Hasura? Hasura es GraphQL primero. Faucet genera API REST con una especificación OpenAPI 3.1 (no GraphQL), se ejecuta como un solo binario que mantiene su configuración en un archivo SQLite integrado e incluye un servidor MCP integrado para agentes de IA.

¿En qué se diferencia Faucet de DreamFactory? DreamFactory es una aplicación PHP/Laravel que se ejecuta en un stack de servidor web con PHP. Faucet es un solo binario Go sin dependencias de tiempo de ejecución. Faucet es totalmente de código abierto bajo la licencia MIT con todas las funciones incluidas, sin niveles de pago requeridos para la funcionalidad principal.

¿En qué se diferencia Faucet de Supabase? Supabase es una plataforma PostgreSQL (base de datos, autenticación, almacenamiento, tiempo real) que usas alojada o autoalojada como un conjunto de servicios. Faucet no aloja tus datos: coloca una API REST y un servidor MCP frente a una base de datos que ya tienes, incluidos MySQL, SQL Server, Oracle, Snowflake y SQLite.

¿Faucet admite GraphQL? Actualmente no. Faucet genera API REST y especificaciones OpenAPI 3.1. El soporte de GraphQL puede agregarse en el futuro.

¿Faucet está listo para producción? Faucet está en desarrollo activo. Es adecuado para herramientas internas, prototipos e integración de agentes de IA. Consulta la página de versiones para la última versión.

¿Pueden los agentes de IA escribir datos a través de Faucet? Sí. Las herramientas MCP incluyen faucet_insert, faucet_update y faucet_delete. Todas las operaciones respetan los roles RBAC, por lo que puedes dar a los agentes de IA acceso de solo lectura o lectura-escritura por tabla. El SQL sin procesar está desactivado a menos que lo permitas para un servicio y concedas todos los verbos.

¿Faucet requiere una base de datos separada para la configuración? No. Faucet usa una base de datos SQLite integrada para toda la configuración, credenciales, roles y claves de API. Todo se almacena localmente en un solo archivo.

Compilación desde el código fuente

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

Stack tecnológico

Go 1.25+ — Router Chi, sqlx, CLI Cobra/Viper
Preact + Vite + Tailwind — Interfaz de administración integrada
SQLite (Go puro, sin CGO) — Almacén de configuración
MCP (Protocolo de contexto de modelo) — Integración de agentes de IA

Documentación

La documentación completa está en wiki.faucetdb.ai:

Primeros pasos: instala, conecta una base de datos, haz tu primera solicitud
Guía de la interfaz de administración: un recorrido por cada página
Servidor MCP: conecta Claude, Cursor, VS Code, Windsurf y ChatGPT
Roles y claves de API (RBAC)
Sintaxis de filtro
Referencia de API
Referencia de CLI
Bloqueo de esquema
Implementación: Docker, Kubernetes, systemd, proxies inversos, lista de verificación de producción
Conectores de bases de datos y tutoriales para PostgreSQL, MySQL / MariaDB, SQL Server, Oracle, Snowflake y SQLite
Arquitectura
Guía para LLM: una referencia compacta escrita para asistentes de codificación de IA

Contribuciones

¡Las contribuciones son bienvenidas! Consulta CONTRIBUTING.md para las pautas, o abre un issue para informar errores y solicitar funciones.

Licencia

MIT — gratuito para uso comercial y personal.

Faucet

Documentación

Faucet: servidor REST API y MCP para cualquier base de datos SQL

Convierte cualquier base de datos SQL en un servidor REST API y MCP seguro.Un solo binario. Un solo comando.

¿Qué es Faucet?

Casos de uso

Cómo funciona

Capturas de pantalla

Características principales

Generación de API

Seguridad y control de acceso

Integración con agentes de IA (MCP)

Experiencia de desarrollo

Bases de datos compatibles

Inicio rápido en 60 segundos

Instalación

Ejecución

Servidor MCP para agentes de IA

Claude Code

Cursor, VS Code, Windsurf

Claude Desktop

ChatGPT

stdio local (solo tu máquina)

Herramientas MCP disponibles

Referencia de CLI

Reglas de acceso (RBAC)

Rutas de API

Parámetros de consulta

Faucet vs PostgREST vs Hasura vs DreamFactory vs Supabase

Preguntas frecuentes

Compilación desde el código fuente

Stack tecnológico

Documentación

Contribuciones

Licencia

Convierte cualquier base de datos SQL en un servidor REST API y MCP seguro.
Un solo binario. Un solo comando.