Free Database Server

15 engines MCP 2026-07-28 Transport Clients MIT

A reference for connecting any MCP client to a free cloud database. Fifteen engines, one endpoint shape, four tools per connection — with every engine's version and dialect, every client's config file and its exact key names, and a troubleshooting section built from the mistakes those key names cause. For a task-oriented walkthrough, the companion repo mcp-database-server-free is organised by job.

Jump to: engines · access model · tools · client setup · troubleshooting · picking an engine · examples

Engines

Engine	Version	Dialect	CLI it speaks	Port	Access
PostgreSQL	16.2	SQL	psql	5432	Native TCP + HTTP + MCP
MySQL	8.0.36	SQL	mysql	3306	HTTP + MCP
MongoDB	7.0.4	Document / NoSQL	mongosh	27017	Native TCP + HTTP + MCP
Redis	7.2.3	Key-Value / In-Memory	redis-cli	6379	Native TCP + HTTP + MCP
SQLite	3.45.1	SQL	sqlite3	—	HTTP + MCP
Apache Cassandra	4.1.4	Wide-Column / CQL	cqlsh	9042	HTTP + MCP
DynamoDB	2024.1	Key-Value / Document	aws CLI	—	HTTP + MCP
ClickHouse	24.1.5	Columnar / OLAP SQL	clickhouse-client	9000	HTTP + MCP
Elasticsearch	8.12.0	Search / Query DSL	curl / ES client	9200	HTTP + MCP
Neo4j	5.17.0	Graph / Cypher	cypher-shell	7687	HTTP + MCP
MariaDB	11.3.2	SQL	mysql	3306	HTTP + MCP
InfluxDB	2.7.4	Flux / InfluxQL	influx	8086	HTTP + MCP
Prometheus	2.50.1	PromQL	promtool / curl	9090	HTTP + MCP
TimescaleDB	2.14.2	SQL (PostgreSQL + Timescale)	psql	5432	HTTP + MCP
CockroachDB	23.2.4	SQL (PostgreSQL-compatible)	cockroach sql / psql	26257	HTTP + MCP

Port is the port that engine's protocol conventionally uses — it tells you which dialect and client tooling apply, not that a socket is listening. Each engine has a page at https://freebase.cloud/free-<slug>-cloud-instance (slugs: postgresql, mysql, mongodb, redis, sqlite, cassandra, dynamodb, clickhouse, elasticsearch, neo4j, mariadb, influxdb, prometheus, timescaledb, cockroachdb), plus a Claude guide at https://freebase.cloud/how-to-connect-claude-to-<slug> — for example the Elasticsearch instance page.

How access works

Two distinct paths. Confusing them is the source of most setup trouble.

Native wire protocol — three engines. PostgreSQL, Redis and MongoDB accept real drivers over their real protocols: psql/libpq/Prisma/SQLAlchemy/pgx, redis-cli/ioredis/redis-py/Lettuce over RESP2, mongosh/Mongoose/the native driver over OP_MSG. Nothing is proxied or reshaped.

postgresql://freebase@HOST:5432/DBNAME    redis://HOST:6379    mongodb://HOST:27017/DBNAME

HTTP and MCP — all fifteen. The other twelve are reached through the hosted HTTP query API and through MCP. They speak their own dialects — CQL to Cassandra, Cypher to Neo4j, Flux to InfluxDB — but the transport is HTTP, not a raw socket. If you are wiring up an AI assistant this is the path you want regardless of engine, because it is identical for all of them:

https://freebase.cloud/api/mcp/YOUR_TOKEN

The token sits in the URL path, so no Authorization header appears anywhere in this document. The consequence: the URL is the credential. Don't commit it, don't paste it into a shared config, and rotate it from Settings → MCP if you do either. Transport is Streamable HTTP, which uses server-sent events internally for streamed responses — not the same thing as the deprecated HTTP+SSE transport with its separate /sse endpoint and POST /messages. Clients offering both: choose streamable.

The four tools

Four tools per connection, prefixed with the connection name you chose, not the engine name. A connection called db gives you:

Tool	Purpose	What it means per engine
db_query	Read, in the engine's native language	SQL · CQL · Cypher · Flux · PromQL · ES query DSL · Mongo find/aggregate · Redis commands
db_store	Insert, upsert, write	INSERT · MERGE · _bulk · line protocol · SET · PutItem
db_list_tables	Enumerate containers	tables · collections · keyspaces · indices · measurements · metric names · keys
db_annotate_table	Attach a human description to a container	so the model knows what the columns mean

Two engines add helpers: PostgreSQL gets pg_dump, pg_restore and pg_tables; SQLite gets sqlite_master and sqlite_version.

Use annotate_table. Highest-return five minutes in this document. A model that can list your tables still has to guess whether status holds 'active' or 1, whether amount_cents is cents or dollars, and whether deleted_at IS NULL is how you filter. One paragraph per table, written once, persists on the connection and applies to every conversation in every client using that token.

Quickstart

Sign up on the freebase.cloud dashboard (no card), create a session, pick an engine, then Settings → MCP → New Token → select the connection → copy the URL. Confirm it works before configuring any client — four tool names printed means anything still broken is configuration:

export FREEBASE_MCP_URL="https://freebase.cloud/api/mcp/YOUR_TOKEN"
python3 examples/list_tools.py

Client setup

Client	Config location	Top-level key	URL key	type value
Claude Desktop / web / Cowork	UI only	—	—	—
Claude Code	.mcp.json / user config	mcpServers	url	"http" (required)
ChatGPT	UI (developer mode)	—	—	—
OpenAI Responses API	request body	tools[]	server_url	"mcp"
Cursor	~/.cursor/mcp.json or .cursor/mcp.json	mcpServers	url	omit entirely
Windsurf	~/.codeium/windsurf/mcp_config.json	mcpServers	serverUrl	—
VS Code / Copilot Chat	.vscode/mcp.json	servers	url	"http"
Zed	settings.json	context_servers	url	—
Cline	MCP settings JSON	mcpServers	url	"streamableHttp"
Roo Code	.roo/mcp.json	mcpServers	url	"streamable-http"
Gemini CLI	settings.json	mcpServers	httpUrl	—
Warp	Settings → AI → Manage MCP servers	(none)	url	—
n8n	MCP Client Tool node	—	Endpoint field	HTTP Streamable
LangChain / LlamaIndex	Python	—	url	"http"

Claude Desktop, Claude web, Cowork

UI only. Settings (⌘, / Ctrl+,) → Connectors (Customize → Connectors in newer builds) → Add custom connector → paste the URL → Add. Enable per conversation with the + button in the composer. Available on Free, Pro, Max, Team and Enterprise; Free accounts get one custom connector. claude_desktop_config.json has no representation for a remote HTTP MCP server — a post telling you to add one there predates streamable HTTP. The engine-specific version of these steps lives at how to connect Claude to PostgreSQL and its siblings for the other slugs.

Claude Code

claude mcp add --transport http db https://freebase.cloud/api/mcp/YOUR_TOKEN
#   --scope project  writes .mcp.json (commit it, minus the token) | --scope user = all projects

{ "mcpServers": { "db": { "type": "http", "url": "https://freebase.cloud/api/mcp/YOUR_TOKEN" } } }

streamable-http is accepted as an alias for http.

ChatGPT

Settings → Apps → Advanced settings → enable developer mode → Apps → Create → paste the endpoint → Auth None → Scan Tools → Create. Also check Settings → Connectors; OpenAI's two docs pages disagree about where this lives. Developer mode is documented for Pro, Plus, Business, Enterprise and Edu; full write access is currently rolling out to Business, Enterprise and Edu workspaces, so on some plans you get read-only tool access today.

OpenAI Responses API

{
  "model": "gpt-5.6",
  "tools": [{
    "type": "mcp",
    "server_label": "db",
    "server_description": "Free cloud database — query and store structured data.",
    "server_url": "https://freebase.cloud/api/mcp/YOUR_TOKEN",
    "require_approval": "never"
  }],
  "input": "List the tables in my database."
}

Cursor, Windsurf, VS Code, Zed

// ~/.cursor/mcp.json  or  .cursor/mcp.json     — NO "type" key
{ "mcpServers": { "db": { "url": "https://freebase.cloud/api/mcp/YOUR_TOKEN" } } }

// ~/.codeium/windsurf/mcp_config.json          — the key is serverUrl
{ "mcpServers": { "db": { "serverUrl": "https://freebase.cloud/api/mcp/YOUR_TOKEN" } } }

// .vscode/mcp.json                             — top-level key is "servers"
{
  "inputs": [{ "type": "promptString", "id": "fb-token", "description": "freebase.cloud MCP token", "password": true }],
  "servers": { "db": { "type": "http", "url": "https://freebase.cloud/api/mcp/${input:fb-token}" } }
}

// Zed settings.json                            — "context_servers", not "mcpServers"
{ "context_servers": { "db": { "url": "https://freebase.cloud/api/mcp/YOUR_TOKEN" } } }

Windsurf is now documented as "Devin Desktop" on docs.devin.ai; Enterprise users must enable MCP in settings first. In VS Code, Command Palette → MCP: Add Server builds the file, and the inputs block keeps the token out of it so the config stays committable.

Cline and Roo Code

Same transport, different spelling, no fallback between them.

// Cline — camelCase
{ "mcpServers": { "db": { "type": "streamableHttp", "url": "https://freebase.cloud/api/mcp/YOUR_TOKEN", "disabled": false, "autoApprove": [] } } }

// Roo Code, .roo/mcp.json — kebab-case
{ "mcpServers": { "db": { "type": "streamable-http", "url": "https://freebase.cloud/api/mcp/YOUR_TOKEN" } } }

Gemini CLI

gemini mcp add --transport http db https://freebase.cloud/api/mcp/YOUR_TOKEN

{ "mcpServers": { "db": { "httpUrl": "https://freebase.cloud/api/mcp/YOUR_TOKEN", "timeout": 5000 } } }

In settings.json the key is httpUrl. Plain url means SSE — a misconfiguration that produces a server which appears to connect and then never returns a tool. The consumer Gemini app does not support custom MCP servers; that is Gemini Enterprise only.

Warp and n8n

Warp: Settings → AI → Manage MCP servers → "Streamable HTTP or SSE Server (URL)". Its paste box takes the server object alone, with no mcpServers wrapper:

{ "db": { "url": "https://freebase.cloud/api/mcp/YOUR_TOKEN" } }

n8n: MCP Client Tool node (1.104.0+). Server Transport → HTTP Streamable, Endpoint → your URL, Authentication → None. The published docs page still shows only the old "SSE Endpoint" field; a current build of the node has the transport dropdown.

LangChain and LlamaIndex

from langchain_mcp_adapters.client import MultiServerMCPClient
client = MultiServerMCPClient({"db": {"transport": "http", "url": "https://freebase.cloud/api/mcp/YOUR_TOKEN"}})
tools = await client.get_tools()

from llama_index.tools.mcp import BasicMCPClient, McpToolSpec
tools = await McpToolSpec(client=BasicMCPClient("https://freebase.cloud/api/mcp/YOUR_TOKEN")).to_tool_list_async()

mcp-remote (fallback only)

For a stdio-only client. Requires Node; its own README calls it experimental, so prefer native HTTP support wherever a client has it.

{ "mcpServers": { "db": { "command": "npx", "args": ["-y", "mcp-remote", "https://freebase.cloud/api/mcp/YOUR_TOKEN", "--transport", "http-only"] } } }

Troubleshooting configuration

Symptom	Cause	Fix
Claude Code errors immediately on startup	url present, type missing	Add "type": "http". This is a hard error, not a warning
Cursor rejects the entry or ignores the server	A "type" key was added	Delete it. In Cursor the presence of url is what marks a server remote
VS Code never sees the server	Config uses mcpServers	The top-level key in .vscode/mcp.json is servers
Windsurf shows the server as unconfigured	Used url	The key is serverUrl
Zed ignores the file	Used mcpServers	Zed's key is context_servers
Gemini CLI connects but lists no tools	Used url	Use httpUrl. Plain url selects the SSE transport
Cline reports an unknown transport	Used streamable-http	Cline wants streamableHttp (camelCase)
Roo Code reports an unknown transport	Used streamableHttp	Roo wants streamable-http (kebab-case)
Warp rejects the pasted JSON	Included the mcpServers wrapper	Paste only the inner server object
Claude Desktop can't find the server in JSON	Remote HTTP servers aren't supported there	Add it through Settings → Connectors instead; note Free is capped at one connector
ChatGPT scans tools but cannot write	Write access still rolling out on your plan	Read works; check your workspace type
Tools appear with unexpected names	Names carry your connection name, not the engine	Rename the connection, or use the names as they are
404 from the endpoint	Token revoked, or a character lost in a copy-paste	Reissue from Settings → MCP
Works in curl, fails in the client	The client is reading a different config file than you edited	Check user-scope versus project-scope paths

Picking an engine

General-purpose relational → PostgreSQL (also the only engine with dump/restore helpers over MCP). An existing MySQL schema, PHP or WordPress → MySQL, or MariaDB for sequences, system-versioned tables and dynamic columns. Flexible documents and Mongoose → MongoDB. Cache, sessions, counters, rate limits, anything with a TTL → Redis. Small and schema-light → SQLite. Analytics over many rows → ClickHouse. Full-text search and ranking → Elasticsearch. Connected data, recommendations, agent memory → Neo4j. Metrics from devices → InfluxDB; from exporters and client libraries → Prometheus; next to relational tables → TimescaleDB. Wide-column at scale or learning CQL → Cassandra. Single-table design against AWS SDK code → DynamoDB. Distributed SQL, serializable by default → CockroachDB.

Examples

examples/list_tools.py prints every tool with its input schema — run it first. dialects.json holds write and read statements for all 15 engines, and examples/clients/ has ready-to-copy config files for ten clients.

node examples/roundtrip.mjs postgresql         # end-to-end write + read
node examples/roundtrip.mjs redis --keep       # leave the data behind

roundtrip.mjs writes bookmark records, reads them back and reports whether what came out matches what went in. Run it against two engines to see how much — and how little — changes between them.

Limits

The free tier is intended for development, prototyping and small production workloads. Engines run at the versions in the table above with their real feature sets: transactions on PostgreSQL, the aggregation pipeline on MongoDB, MergeTree on ClickHouse, Cypher and APOC on Neo4j, the aggregations framework on Elasticsearch. No SLA, uptime figure, backup guarantee or storage number is claimed here, because none is verified — the dashboard shows current quotas. Treat anything you cannot afford to lose as needing its own backup. For production scale, dedicated resources and a support relationship, the vendors' own managed offerings remain the right answer.

Links

freebase.cloud · MCP specification (revision 2026-07-28) · transport reference

---

Affiliation. freebase.cloud is an independent service and is not affiliated with Anthropic, OpenAI, Google, Microsoft, Anysphere, Codeium, Zed Industries, Warp, n8n, Oracle, MongoDB, Inc., Redis Ltd., Elasticsearch B.V., Neo4j, Inc., InfluxData, ClickHouse, Inc., the Apache Software Foundation, AWS, Timescale, Inc., Cockroach Labs or the PostgreSQL Global Development Group.