Docs · databasedmcp

Connect Claude

In Claude on the web, desktop or mobile:

Open Settings → Connectors. Find databasedmcp in the directory, or choose Add custom connector and enter https://databasedmcp.com/mcp.
Select Connect. A databasedmcp page opens: sign in with your email or Google. A new email gets a new account on the Free plan.
Check the app and the account it will use, and select Allow.
Turn databasedmcp on for a conversation from the tools menu, and ask Claude to keep something.

Claude asks before running anything that changes or deletes data. Reading runs without asking.

Claude Code

Terminal

claude mcp add --transport http databased https://databasedmcp.com/mcp

Then run /mcp in Claude Code, pick databased and choose Authenticate. Your browser opens the same sign-in and Allow page. Add --scope project to share the server with everyone working in the repo; each person signs in with their own account.

Other agents, with an API key

Agents without MCP sign-in use an API key. Create one on the API keys page, keep it in an environment variable, and point the agent at the server:

.mcp.json

{
  "mcpServers": {
    "databased": {
      "type": "http",
      "url": "https://databasedmcp.com/mcp",
      "headers": {
        "Authorization": "Bearer ${DATABASED_API_KEY}"
      }
    }
  }
}

Codex

~/.codex/config.toml

[mcp_servers.databased]
url = "https://databasedmcp.com/mcp"
bearer_token_env_var = "DATABASED_API_KEY"

opencode

opencode.json

{
  "mcp": {
    "databased": {
      "type": "remote",
      "url": "https://databasedmcp.com/mcp",
      "oauth": false,
      "headers": {
        "Authorization": "Bearer {env:DATABASED_API_KEY}"
      }
    }
  }
}

What to ask

You don't design a schema. Tell Claude what's worth keeping and it creates databases, tables and a guide for how to use them:

Keep a notes database of what we learn about this codebase.
Log these benchmark runs in databasedmcp and compare them with last week's.
Use databasedmcp as shared project memory for this repo, from the project template.
What did we decide about the billing database?

Every agent on your account sees the same databases. You can browse them, and run read-only SQL, on the website.

Any number of sessions and agents can read and change the same database, but none of them is told when another one writes. An agent sees new rows and messages when it looks: when you ask it to, before it starts a piece of work, at regular checkpoints, or from a hook in clients that have them. Sending messages between agents shows how.

Tools

Each database is a SQLite database. The SQL tools take SQLite statements, with values passed as parameters.

Tool	What it does	Effect
`list_databases` List databases	List this tenant's databases, most recently updated first, with size and when each was last written.	Reads only
`create_database` Create database	Create an empty database, start from a template (schema plus guide), or fork an existing one with `from` (copies schema, data and guide; the source is not modified; a large source is copied in chunks, so stop writing to it while it is forked).	Adds, never removes
`get_database` Describe database	Get a database's metadata, guide, size and full schema (CREATE statements and row counts per table). Read this before using a database.	Reads only
`update_database` Rename or describe database	Rename a database and/or change its description or guide.	Changes or deletes data
`delete_database` Delete database	Permanently delete a database and all its data. Forks of it are unaffected. Works at every limit and isn't counted as a call.	Changes or deletes data
`query` Run read-only SQL	Run one read-only SQLite statement (SELECT, WITH … SELECT, EXPLAIN). Returns columns and rows as arrays. Default 100 rows, max 1000; `truncated` means more rows exist (page with LIMIT/OFFSET). Text longer than max_cell_chars is cut.	Reads only
`execute` Run one write	Run one INSERT, UPDATE, DELETE or REPLACE (RETURNING supported, up to 100 rows). For several statements use transaction; for schema changes use alter_schema.	Changes or deletes data
`transaction` Run statements atomically	Run several statements atomically: if any fails, none are applied. Accepts reads, writes and schema changes. Returns one result per statement.	Changes or deletes data
`alter_schema` Change schema	Apply CREATE/ALTER/DROP statements for tables, views, indexes and triggers atomically. Returns the resulting schema.	Changes or deletes data
`create_index` Create index	Create an index on one or more columns of a table.	Adds, never removes
`drop_index` Drop index	Drop an index by name. get_database lists indexes.	Changes or deletes data
`get_usage` Show usage and limits	Show this week's usage against the plan's limits: tool calls, storage, databases, and the largest value and database. Works at every limit and isn't counted as a call.	Reads only
`send_feedback` Send feedback	Tell the databasedmcp team about a bug, a confusing error or guide, or a missing feature. Doesn't touch your databases.	Adds, never removes

Writes that contain known kinds of secrets (API keys, tokens, private keys, passwords in URLs) are rejected before they're stored.

Prompts

Prompts are shortcuts you start yourself, such as /mcp__databased__project in Claude Code. The ones that set up a routine offer to add a line to your CLAUDE.md, so later sessions follow it too.

project: Use databasedmcp as project memory: Set up or join the shared task board and memory for this repo, then catch up.
session: Track this session: Register this session in the shared sessions record, after reading what earlier sessions left.
steer: Steer a running session: Send a message to a running agent session: stop it, change its direction, or tell it something.
remember: Remember this: Store something in databasedmcp so later sessions and other agents can find it.
recall: Recall: Search databasedmcp for what earlier sessions and other agents stored about a topic.
learnings: Learn from tool problems: Keep a shared record of tool and command problems and their fixes, and check it before retrying a failure.
feedback: Send feedback about databasedmcp: Tell the databasedmcp team what worked, what didn't, or what's missing.

Templates

A template is a ready schema and guide that Claude can start a database from. You can change the schema afterwards.

project: Multi-agent coordination and memory for one repo: a task board with atomic claims, leases, dependencies and file territory, plus decisions, conventions, findings, questions and handoffs.
notes: A searchable knowledge base for any domain: notes with title, body, tags, source and supersession, with full-text search.
learnings: Problems agents hit with tools and commands, and what fixed them: search by error text before retrying, record fixes and dead ends. One per account, shared across projects.
log: Append-only records of runs, experiments, evals and benchmarks: one row per run with its metrics, and a view comparing the latest run with the previous one and a baseline.
sessions: What each agent session did, so the next one doesn't start blind: one row per session (scope, goal, state, result, next, workflow) across repos, providers and devices, plus messages to steer running sessions. One per account.

Limits

	Free	Starter	Pro
Tool calls a week	100	1,000	10,000
Storage	1 MB	100 MB	1 GB
Databases	10	100	1,000
Largest value	8 KB	1 MB	10 MB
Connected agents (API keys and apps, together)	1	3	1,000
People	1	3	100

Tool calls reset every Monday at 00:00 UTC. At a limit, writes stop with an error that names it; reading and deleting keep working. Starter is €5 a month and Pro €20, on the Billing page; limit errors link there.

Troubleshooting

Connecting

Claude doesn't list the databasedmcp tools: Check that the connector is turned on for this conversation in the tools menu. In Claude Code, run /mcp and choose Authenticate if databased isn't connected.
Sign-in keeps coming back, or the sign-in link doesn't work: A sign-in link works once and expires after 15 minutes; ask for a new one. Open it in the same browser you're connecting from. Google and email reach the same account when the address matches.
An agent with an API key gets 401: The key was deleted, or the environment variable isn't set where the agent runs. Create a key on the API keys page and restart the agent. A disconnected app signs in again the next time you connect it.

Errors from the tools

Every error starts with a code in brackets and says what to do. Your agent can usually fix it by itself; these are the ones you might see:

[limit_exceeded]: Your account hit a plan limit: the error names it. Reading and deleting keep working. Tool calls start again on Monday at 00:00 UTC, or a bigger plan raises the limit on Billing.
[secret_detected]: The write contained something that looks like an API key, token or private key, so nothing was stored. Store where the secret lives (the name of an environment variable) instead.
[conflict]: A write with expect_changes didn't change the expected number of rows, usually because another agent changed them first. Nothing was applied: read the rows again and retry.
[sql_error]: SQLite rejected the statement. The message has SQLite's own error; the agent fixes the SQL and tries again.
[not_found], [already_exists]: The database, table or index name doesn't exist, or already does. list_databases and get_database show what's there.
[invalid_argument]: A tool argument is malformed, such as a database name with characters outside lowercase letters, digits, - and _.
[unauthenticated], [forbidden]: The key or connection is no longer valid, or your account can't do this. Reconnect, or check your role on the Members page.
[unavailable]: The database server is restarting. Wait a minute and retry; nothing was lost.
[internal]: Something broke on our side and we logged it. Retry once; if it happens again, tell us.

If a problem persists, it's always OK to email support@databasedmcp.com. Say what you tried, the error code and roughly when it happened. Your agent can also report it with the send_feedback tool.

Disconnect

Connected apps are listed on the API keys page. Disconnect turns an app away from its next call. In Claude you can also remove the connector under Settings → Connectors. Your databases stay until you delete them.

Privacy and support

How we handle your data: privacy policy. Questions and problems: support@databasedmcp.com. Your agents can also report problems with the send_feedback tool.