Turns any SQL database into a governed REST API and MCP server so AI clients can browse schemas and query or modify data.
Also known as faucetdb/faucet, @faucetdb/faucet
- Stars
- 176
- Tools
- 8
- Downloads, 30 days
- 323
- Latest version
- 0.1.15
- Last commit
- Oct 18, 2026
- License
- MIT
What is Faucet MCP?
Faucet turns any SQL database into a governed REST API and MCP server so AI clients can browse schemas and query or modify data. It exposes 8 tools, such as faucet_delete, faucet_describe_table, faucet_insert.
Summary generated from the project's README
About Faucet MCP server
Developers can transform existing SQL databases into governed REST APIs and MCP servers using Faucet. This single Go binary connects to PostgreSQL, MySQL, MariaDB, SQL Server, Oracle, Snowflake, or SQLite to automatically generate CRUD endpoints and OpenAPI 3.1 documentation from your schema at runtime. It is designed for those who need to provide AI agents with secure, structured access to data without writing custom backend code or managing complex ORMs.
Users can deploy the server locally via npm, Homebrew, or Docker, or run it as a single binary. The system includes a built-in admin UI for managing connections, browsing schemas, and configuring role-based access control (RBAC). AI clients like Claude, Cursor, and Windsurf can interact with your data through the `/mcp` endpoint using API keys. This setup ensures that AI agents respect the same permission rules and table-level verb restrictions as standard API clients.
What you can do with it
- 1Instant backend generationCreate a full CRUD REST API for a frontend application by simply pointing the server at a database.
- 2Governed AI data accessProvide AI agents with controlled read and write permissions to your SQL data via the Model Context Protocol.
- 3Legacy database modernizationExpose modern RESTful interfaces to older database versions without changing the underlying infrastructure.
- 4Multi-database aggregationQuery multiple different database engines through a single unified API interface.
Written from the project's README. Every use case is checked against a quote from it.
How to install Faucet MCP
Formats verified 10 Nov 2026Add to CursorAdd to GooseInstall Faucet MCP in Claude Code
$ claude mcp add faucet -- npx -y @faucetdb/faucet mcpInstall Faucet MCP in Cursor
~/.cursor/mcp.json
{
"mcpServers": {
"faucet": {
"command": "npx",
"args": [
"-y",
"@faucetdb/faucet",
"mcp"
]
}
}
}Install Faucet MCP in VS Code
.vscode/mcp.json
{
"servers": {
"faucet": {
"type": "stdio",
"command": "npx",
"args": [
"-y",
"@faucetdb/faucet",
"mcp"
]
}
}
}Install Faucet MCP in VS Code CLI
$ code --add-mcp '{"name":"faucet","type":"stdio","command":"npx","args":["-y","@faucetdb/faucet","mcp"]}'Install Faucet MCP in Claude Desktop
claude_desktop_config.json
{
"mcpServers": {
"faucet": {
"command": "npx",
"args": [
"-y",
"@faucetdb/faucet",
"mcp"
]
}
}
}Install Faucet MCP in Codex
$ codex mcp add faucet -- npx -y @faucetdb/faucet mcpInstall Faucet MCP in Codex config.toml
~/.codex/config.toml
[mcp_servers.faucet] command = "npx" args = ["-y", "@faucetdb/faucet", "mcp"]
Install Faucet MCP in Gemini CLI
$ gemini mcp add -s user faucet npx -- -y @faucetdb/faucet mcpInstall Faucet MCP in Gemini settings.json
~/.gemini/settings.json
{
"mcpServers": {
"faucet": {
"command": "npx",
"args": [
"-y",
"@faucetdb/faucet",
"mcp"
]
}
}
}Started by HostedMCP on 16 Nov 2026
We ran this command for @faucetdb/faucet 0.1.15 in an isolated container with no network and no keys. It answered and listed 8 tools.
Faucet MCP tools 8
Read from the server with tools/listfaucet_deleteActionDelete records from a database table that match a filter expression. A filter is required to prevent accidental full-table deletes. Returns the number of deleted records. Requires DELETE permission on the table.
faucet_describe_tableRead-onlyGet the detailed schema for a specific table, including all columns with their types, nullability, defaults, primary keys, foreign keys, and indexes. Use this to understand table structure before writing queries. Requires GET permission on the table's schema (_schema/{table}).
faucet_insertActionInsert one or more records into a database table. Each record is a JSON object mapping column names to values. Returns the inserted records (with auto-generated fields like IDs) if the database supports RETURNING. Requires POST permission on the table.
faucet_list_servicesRead-onlyList all database services configured in Faucet. Returns each service's name, driver type, active status, and access mode. Use this first to discover available databases before querying. Only services your role has access to are listed.
faucet_list_tablesRead-onlyList all tables in a database service, including approximate row counts and column summaries. Use this to explore what data is available before querying specific tables. Requires GET permission on _table.
faucet_queryRead-onlyQuery records from a database table with optional filtering, field selection, ordering, and pagination. Returns results as JSON. Requires GET permission on the table. Filter syntax (DreamFactory-compatible): - Simple: name = 'John' - Comparison: age > 21, price <= 100 - Logical: status = 'active' AND role = 'admin' - IN: status IN ('active', 'pending') - LIKE: name LIKE 'J%' - NULL: email IS NOT NULL - BETWEEN: age BETWEEN 18 AND 65 - CONTAINS: name CONTAINS 'smith' Order syntax: 'column ASC, other_column DESC'
faucet_raw_sqlActionExecute a raw SQL query against a database service. Only available for services with raw_sql_allowed enabled. Use faucet_list_services to check which services allow raw SQL. Because arbitrary SQL can touch any object, it requires a role rule granting all verbs (GET, POST, PUT, PATCH, DELETE) on the _sql component of the service. The statement is executed as-is and may modify data; it is refused on services flagged read_only. Parameters should be passed as an array and referenced with positional placeholders ($1, $2 for PostgreSQL; ?, ? for MySQL).
faucet_updateActionUpdate records in a database table that match a filter expression. The record object contains the column values to set. A filter is required to prevent accidental full-table updates. Requires PATCH permission on the table.
Configuration
FAUCET_DATA_DIRFaucet data directory holding the databases you connected with `faucet serve` or `faucet db add`. Default: ~/.faucet. stdio mode runs with local admin rights.
Automated checks
Ran Nov 16, 2026Full report →Passed our automated checks. That is not a security audit: read the code and give the server the narrowest access it needs. How checks work
- Source repository linked and reachablefaucetdb/faucet is public and reachablegithub.com/faucetdb/faucet ↗Pass
- Package names this repository as its source@faucetdb/faucet names faucetdb/faucet as sourcenpmjs.com/package/@faucetdb/faucet ↗Pass
- Build provenance (Sigstore attestation)No build attestation published for this releaseNot checked
- Open source license (OSI)MITspdx.org/licenses/MIT.html ↗Pass
- Commit or release in the last yearLast commit or release 2026-10-18github.com/faucetdb/faucet ↗Pass
- OpenSSF ScorecardNot checked
- Package name not close to a popular packageNo popular package one edit away from @faucetdb/faucetPass
- No critical advisory in the package or its dependencies7 resolved dependencies checked; no critical advisoryosv.dev ↗Pass
- No hidden instructions to the model8 tool descriptions and the README read; no override phrases, credential paths or hidden charactersPass
- Destructive tools are labelledNo tool named like delete, drop or execPass
- Remote endpoint answers the MCP handshakeNot checked
README
View on GitHubWhat is Faucet?
Faucet is a database-to-REST-API gateway — a lightweight, self-hosted server that connects to your SQL databases, introspects the schema, and generates a full CRUD REST API with authentication, role-based access control (RBAC), and OpenAPI documentation. It also exposes an MCP server at /mcp so AI agents and AI app builders (Claude, ChatGPT, Cursor, VS Code, Windsurf, Base44, Replit) can query your data through the same roles and API keys.
Think of it as an open-source alternative to DreamFactory, PostgREST, or Hasura, with multi-database support, a built-in admin UI, and native AI agent integration, all in a single binary. See how it compares.
Use Cases
- Instant backend for apps — Skip writing CRUD APIs by hand. Point Faucet at your database and start building your frontend.
- AI agent data access — Give Claude, GPT, or any MCP-compatible agent governed, read/write access to your databases.
- Internal tools & dashboards — Generate APIs for internal databases without modifying existing infrastructure.
- Legacy database modernization — Put a REST API in front of SQL Server 2012, MySQL 5.7, or PostgreSQL 9.6 without code changes.
- Multi-database aggregation — Connect PostgreSQL, MySQL, SQL Server, Oracle, and more to a single Faucet instance and query them all through one API.
- Rapid prototyping — Go from empty database to working API in under 60 seconds.
How It Works
┌──────────────┐ ┌───────────────────────────────────────┐ ┌──────────────┐
│ 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/ │
└───────────────────────────────────────┘ └──────────────┘
Connect any SQL database → Faucet introspects the schema → Instantly generates REST endpoints, OpenAPI docs, MCP tools, and an Admin UI — all secured with API keys, JWT auth, and role-based permissions.
Screenshots
See the Admin UI guide for a tour of every page.
Key Features
API Generation
- Full CRUD REST API — GET, POST, PUT, PATCH, DELETE with filtering, ordering, and pagination
- Schema introspection — Discovers tables, columns, types, and constraints at runtime
- Schema DDL — Create, alter, and drop tables via API
- Stored procedure calls — Execute stored procedures with typed parameters
- Human-readable query filters —
(age > 21) AND (status = 'active') - OpenAPI 3.1 spec — Auto-generated from live database schema at
/openapi.json
Security & Access Control
- API key authentication — SHA-256 hashed keys with per-key role assignment
- JWT authentication — HMAC-SHA256 signed tokens for admin sessions
- Role-based access control (RBAC) — Per-table verb permissions (GET, POST, PUT, PATCH, DELETE)
- Row-level security filters — Filter expressions are stored per access rule and returned by the API; applying them to queries is planned and not enforced yet
- Schema contract locking — Lock your API contract against silent breaking schema changes with three modes (none, auto, strict), drift detection, and CLI management
AI Agent Integration (MCP)
- Built-in MCP server — 8 tools + 2 resources for Model Context Protocol, served at
/mcpon the same port as the REST API - Works with your AI tools — Copy-ready configs for Claude Code, Claude Desktop, Cursor, VS Code and Windsurf; ChatGPT via a Custom GPT Action on
/openapi.json - Streamable HTTP + stdio transport — API-key authenticated over the network, or stdio on your own machine
- Governed AI queries — AI agents respect the same RBAC rules as API clients
Developer Experience
- Single binary — Zero external dependencies, cross-platform (Linux, macOS, Windows)
- Embedded admin UI — connect databases with host, port, user and password (no connection strings), test before saving, browse schemas and data, build roles and keys, and copy ready-made MCP configs for Claude, Cursor, VS Code and more. Works offline; light and dark themes
- SQLite config store — All configuration stored locally, no external database required
- npm + Homebrew + Docker — Install in seconds on any platform (
npx @faucetdb/faucet) - Health endpoints —
/healthzand/readyzfor Kubernetes-style probes
Supported Databases
| Database | Versions | Cloud Variants | Tutorial |
|---|---|---|---|
| PostgreSQL | 9.6 – 17 | Amazon RDS, Aurora, Supabase, Neon, Azure Database | Guide |
| MySQL | 5.7 – 9.x | Amazon RDS, Aurora MySQL, PlanetScale, Azure MySQL | Guide |
| MariaDB | 10.2 – 11.x | Via MySQL driver | MySQL guide |
| SQL Server | 2012 – 2022 | Azure SQL Database, Amazon RDS | Guide |
| Oracle | 12c – 26ai | Oracle Cloud (OCI), Amazon RDS, Azure | Guide |
| Snowflake | Current | AWS, Azure, GCP | Guide |
| SQLite | 3.35+ | Local file, in-memory | Guide |
Connector details, SSL options and driver notes: Database connectors.
60-Second Quickstart
Install
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
Binary download: See GitHub Releases for pre-built binaries (Linux, macOS, Windows).
Run
faucet serve
Open http://localhost:8080. The setup wizard creates your admin account and connects your first database: pick the engine, enter host, port, username and password, click Test connection, and save. Every table gets REST endpoints at /api/v1/<name>/_table/<table> and MCP tools right away. Then create a role on the Roles page and an API key on the API keys page, which hands you a ready-to-run curl command and an MCP setup command that already contain the new key.
Prefer the terminal? The same steps with the 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 still works if you already have a connection string. A running server picks up databases added through the admin UI or API immediately; databases added with faucet db add are loaded the next time the server starts.
MCP Server for AI Agents
Faucet includes a built-in Model Context Protocol (MCP) server, so AI agents such as Claude, Cursor, VS Code Copilot and Windsurf can query and modify your databases through governed, tool-based access.
faucet serve exposes the MCP server at http://localhost:8080/mcp (Streamable HTTP), on the same port as the REST API. Authenticate with an API key in the X-API-Key header. The key's role controls which databases and tables the agent can see and change, exactly as for the REST API.
The AI agents (MCP) page in the admin UI generates every config below with your key filled in. Replace YOUR_API_KEY with a key from the API keys page or 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 or .cursor/mcp.json):
{
"mcpServers": {
"faucet": {
"url": "http://localhost:8080/mcp",
"headers": { "X-API-Key": "YOUR_API_KEY" }
}
}
}
VS Code (.vscode/mcp.json, used by Copilot Chat in agent mode):
{
"servers": {
"faucet": {
"type": "http",
"url": "http://localhost:8080/mcp",
"headers": { "X-API-Key": "YOUR_API_KEY" }
}
}
}
Windsurf (~/.codeium/windsurf/mcp_config.json): the same as Cursor, with serverUrl instead of url.
Claude Desktop
Claude Desktop's config file only launches local commands, so use the mcp-remote bridge (needs Node.js) in claude_desktop_config.json:
{
"mcpServers": {
"faucet": {
"command": "npx",
"args": ["-y", "mcp-remote", "http://localhost:8080/mcp", "--header", "X-API-Key:YOUR_API_KEY"]
}
}
}
For a Faucet server on another machine over plain http://, add "--allow-http" to the args. See examples/claude-desktop-config.json.
ChatGPT
ChatGPT connectors sign in with OAuth, which Faucet does not support. Use a Custom GPT Action instead: expose Faucet over HTTPS, import https://your-host/openapi.json, and set authentication to API key with the custom header X-API-Key.
Local stdio (your machine only)
MCP clients can also launch Faucet as a subprocess. stdio mode reads the databases configured with faucet serve or faucet db add (~/.faucet by default) and runs with local admin rights: roles are not applied. Use it only on your own machine; for anything shared, use /mcp with an API key.
{
"mcpServers": {
"faucet": {
"command": "npx",
"args": ["-y", "@faucetdb/faucet", "mcp"]
}
}
}
The same config is in examples/mcp-stdio-config.json. If faucet is installed (Homebrew, Go or a release binary), use "command": "faucet", "args": ["mcp"]. faucet mcp --transport http --port 3001 runs a standalone, API-key authenticated HTTP server on its own port.
Full guide, including a curl test and the OpenAI Responses API: MCP server docs.
Available MCP Tools
| Tool | Description |
|---|---|
faucet_list_services |
List all connected databases |
faucet_list_tables |
List tables in a database |
faucet_describe_table |
Get column names, types, and constraints |
faucet_query |
Query records with filters, ordering, pagination |
faucet_insert |
Insert new records |
faucet_update |
Update existing records |
faucet_delete |
Delete records |
faucet_raw_sql |
Execute raw SQL (admin only) |
CLI Reference
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
Access rules (RBAC)
A role is a list of rules {service_name, component, verb_mask}. An API key inherits the rules of the role it is bound to; every request is checked against them. Admin JWT sessions (the dashboard and /api/v1/system/*) bypass RBAC.
Verb bits — combine with bitwise OR:
| Verb | Bit |
|---|---|
| GET | 1 |
| POST | 2 |
| PUT | 4 |
| PATCH | 8 |
| DELETE | 16 |
| all | 31 |
Matching (case-sensitive — patterns must match the service and table names exactly as they appear in the URL):
service_name:*(any service), an exact name (mydb), or a prefix wildcard (prod_*)component:*(anything), an exact component (_table/customers,_schema), a prefix wildcard (_table/*— every table and the_tablelisting), or a bare name (customers, which matches_table/customers,_schema/customers, ...)
Fail closed. A role with no rules, a rule with verb_mask 0, or an inactive role denies everything with 403 and an error envelope that says why:
{"error":{"code":403,"message":"Role \"readonly\" does not permit POST on mydb/_table/orders",
"context":{"role":"readonly","service":"mydb","component":"_table/orders","verb":"POST"}}}
Services flagged read_only reject every non-GET request regardless of role.
MCP. Tools map onto the same verbs: faucet_query = GET, faucet_insert = POST, faucet_update = PATCH, faucet_delete = DELETE, faucet_list_tables = GET on _table, faucet_describe_table = GET on _schema/{table}. faucet_raw_sql requires all five verbs on a rule matching component _sql (e.g. *). faucet_list_services only lists services the role can reach. faucet mcp in stdio mode runs with local admin privileges; faucet mcp --transport http requires the same API key or JWT credentials as the main server.
Granting rules from the 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
or through the admin API, which replaces the whole rule list:
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"}
]
}'
Row-level
filterson a rule are stored and returned by the API but are not yet applied to queries.
Upgrading. Before this fix, role rules were stored but never enforced for API-key requests. Roles created with faucet role create that were never given rules will now be denied with 403 — grant them rules with faucet role grant or the admin UI. Roles created in the admin UI default to GET-only on all services, so API keys that previously wrote data through such roles now need POST/PUT/PATCH/DELETE granted explicitly. On startup faucet serve logs a warning for every role that has active API keys but would deny all requests (no rules, only verb_mask: 0 rules, or inactive), together with the faucet role grant command that fixes it.
The admin JWT signing secret is no longer a built-in default: when auth.jwt_secret / FAUCET_AUTH_JWT_SECRET (alias FAUCET_JWT_SECRET) is not configured, a random secret is generated on first start and persisted in the data directory. Existing admin sessions are invalidated by the upgrade unless the secret was already configured — log in again.
API Routes
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
Query Parameters
| Parameter | Example | Description |
|---|---|---|
filter |
(age > 21) AND (name LIKE 'A%') |
SQL-style filter syntax with safe parameterization |
order |
created_at DESC, name ASC |
Sort order |
limit |
25 |
Max records to return |
offset |
50 |
Skip N records for pagination |
fields |
id,name,email |
Select specific columns |
ids |
1,2,3 |
Filter by primary key values |
include_count |
true |
Include total record count in response metadata |
Faucet vs PostgREST vs Hasura vs DreamFactory vs Supabase
A short comparison of how each project is shaped. It covers only facts you can check in each project's own docs; if something here is out of date, please open an issue.
| Faucet | PostgREST | Hasura | DreamFactory | Supabase | |
|---|---|---|---|---|---|
| Primary API | REST + OpenAPI 3.1, plus a built-in MCP endpoint at /mcp |
REST | GraphQL-first | REST | REST (via PostgREST), realtime, auth, storage |
| Databases | PostgreSQL, MySQL, MariaDB, SQL Server, Oracle, Snowflake, SQLite | PostgreSQL | PostgreSQL plus other sources via connectors | Many SQL and NoSQL sources | PostgreSQL |
| Admin UI | Embedded in the binary | None | Console | Web admin app | Studio |
| How you run it | Single Go binary, config in embedded SQLite | Single binary | Engine plus a Postgres metadata database (v2) | PHP/Laravel application | Hosted platform, or self-host a multi-service Docker stack |
| License | MIT | MIT | Apache 2.0 (graphql-engine repo) | Apache 2.0 (open-source edition), paid editions available | Apache 2.0 |
Faucet MCP questions
How do I add Faucet MCP to Claude Code?
Run claude mcp add faucet -- npx -y @faucetdb/faucet mcp in your terminal. Add --scope user to make it available in every project.
How do I add Faucet MCP to Cursor?
Open ~/.cursor/mcp.json and add the server under mcpServers, using the Cursor config shown in the install section above.
What tools does Faucet MCP provide?
It exposes 8 tools, including faucet_delete, faucet_describe_table, faucet_insert, faucet_list_services, faucet_list_tables.
Which databases can Faucet connect to?
Faucet supports PostgreSQL, MySQL, MariaDB, SQL Server, Oracle, Snowflake and SQLite, including many cloud variants.
How do AI agents authenticate to the Faucet MCP server?
The MCP endpoint is served at /mcp over Streamable HTTP and is authenticated with an API key, or you can use stdio locally.
Does Faucet apply role-based access control to AI agent queries?
Yes, MCP tools use the same roles and API keys as regular API clients.
Where is the MCP server exposed relative to the REST API?
The MCP server runs at /mcp on the same port as the REST API.
Do I need to generate code to create API endpoints?
No, endpoints, OpenAPI specs and MCP tools are generated from the database schema at runtime.