# freebase.cloud [Health: Active]

**Category:** 🗄️ Databases  
**Repository:** https://github.com/freebase-cloud/free-database-mcp-server  
**GitHub Stars:** 0  
**Views:** 0  
**Installs:** 0  
**Upvotes:** 0  
**Directory Page:** https://allmcps.com/mcp/freebase-cloud

## Description
Free cloud databases over MCP: query, store, list and annotate across 15 engines.

## Claude Desktop Quick Installation
Install path detected from listing signals. Uses `npx` (confidence: high):

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

## Documentation & README

# free-database-mcp-server

[![15 engines](https://img.shields.io/badge/engines-15-2EA043?style=flat-square)](https://freebase.cloud)
[![MCP 2026-07-28](https://img.shields.io/badge/MCP-2026--07--28-6E56CF?style=flat-square)](https://modelcontextprotocol.io/specification)
[![Transport](https://img.shields.io/badge/transport-streamable_HTTP-1D9BF0?style=flat-square)](https://modelcontextprotocol.io/specification/basic/transports)
[![Clients](https://img.shields.io/badge/clients-14_documented-8A2BE2?style=flat-square)](#client-setup)
[![MIT](https://img.shields.io/badge/license-MIT-lightgrey?style=flat-square)](LICENSE)

A reference for connecting any MCP client to
[a free cloud database](https://freebase.cloud). 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](#engines) · [access model](#how-access-works) · [tools](#the-four-tools) ·
[client setup](#client-setup) · [troubleshooting](#troubleshooting-configuration) ·
[picking an engine](#picking-an-engine) · [examples](#examples)

## Engines

| Engine | Version | Dialect | CLI it speaks | Port | Access |
|---|---|---|---|---|---|
| [PostgreSQL](https://freebase.cloud/free-postgresql-cloud-instance) | 16.2 | SQL | `psql` | 5432 | Native TCP + HTTP + MCP |
| MySQL | 8.0.36 | SQL | `mysql` | 3306 | HTTP + MCP |
| [MongoDB](https://freebase.cloud/free-mongodb-cloud-instance) | 7.0.4 | Document / NoSQL | `mongosh` | 27017 | Native TCP + HTTP + MCP |
| [Redis](https://freebase.cloud/free-redis-cloud-instance) | 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](https://freebase.cloud/free-clickhouse-cloud-instance) | 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](https://freebase.cloud/free-neo4j-cloud-instance) | 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](https://freebase.cloud/free-elasticsearch-cloud-instance).

## 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](https://freebase.cloud) 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](https://freebase.cloud/free-sqlite-cloud-instance)** 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](https://freebase.cloud) (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:

```bash
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](https://freebase.cloud/how-to-connect-claude-to-postgresql)
and its siblings for the other slugs.

### Claude Code

```bash
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
```
```json
{ "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

```json
{
  "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

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

```json
// ~/.codeium/windsurf/mcp_config.json          — the key is serverUrl
{ "mcpServers": { "db": { "serverUrl": "https://freebase.cloud/api/mcp/YOUR_TOKEN" } } }
```
```json
// .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}" } }
}
```
```json
// 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.

```json
// Cline — camelCase
{ "mcpServers": { "db": { "type": "streamableHttp", "url": "https://freebase.cloud/api/mcp/YOUR_TOKEN", "disabled": false, "autoApprove": [] } } }
```
```json
// Roo Code, .roo/mcp.json — kebab-case
{ "mcpServers": { "db": { "type": "streamable-http", "url": "https://freebase.cloud/api/mcp/YOUR_TOKEN" } } }
```

### Gemini CLI

```bash
gemini mcp add --transport http db https://freebase.cloud/api/mcp/YOUR_TOKEN
```
```json
{ "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:

```json
{ "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

```python
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()
```
```python
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.

```json
{ "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](https://freebase.cloud) |
| 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](https://freebase.cloud/free-mysql-cloud-instance)**, 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](https://freebase.cloud/free-timescaledb-cloud-instance)**. Wide-column at scale or learning CQL → **[Cassandra](https://freebase.cloud/free-cassandra-cloud-instance)**. Single-table design against
AWS SDK code → **DynamoDB**. Distributed SQL, serializable by default → **[CockroachDB](https://freebase.cloud/free-cockroachdb-cloud-instance)**.

## 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.

```bash
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](https://freebase.cloud) 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](https://freebase.cloud) ·
[MCP specification](https://modelcontextprotocol.io/specification) (revision 2026-07-28) ·
[transport reference](https://modelcontextprotocol.io/specification/basic/transports)

---

**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.