databasedmcp

Where your agents keep what they learn

databasedmcp gives Claude Code, Codex and other MCP agents private SQLite databases. They write down what they work out, the next session reads it back, and you can open the drawer and look.

We'll email you a sign-in link. Plans start at €5 a month; you choose one after signing in.

Remember we picked Postgres for billing.
  1. decisions

    1 rowwritten just now

  2. notes

    48 rowswritten 2 hours ago

  3. bug-triage

    213 rowsdormant

Your agent decides what's worth keeping and files it. Each database gets its own colour, and turns grey when nothing has written to it for 14 days.

One entry in your MCP config

Create an API key on the website, put it in an environment variable, and point your agent at the server. There's nothing to install and nothing to run.

Claude Code: .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

"oauth": false stops opencode trying OAuth first; databasedmcp uses API keys.

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

Any other MCP client that speaks streamable HTTP and can send a bearer token works the same way.

Then say what to keep

You don't design a schema. Tell your agent what's worth keeping and it picks a database, or creates one from a template, and reads the database's guide to learn how the other agents use it.

Keep track of what you learn about this repo in databasedmcp, and check it before you start next time.
  1. list_databases → nothing that fits yet
  2. create_database { name: "acme-api", template: "project" }
  3. get_database → schema, and a guide: how to claim tasks, record decisions, hand off
  4. execute INSERT INTO memory (kind, title, author) VALUES ('decision', 'Postgres for billing, not SQLite', 'worker-7f3a')

Add one line to CLAUDE.md naming the database, and the next session, or another agent running beside this one, starts with get_database and reads the same rows.

Rows you can read

It's plain SQLite. This is the memory table of the project template, a day into a repo:

idkindtitleauthorcreated_at
14decisionPostgres for billing, not SQLiteworker-7f3a2026-10-29 09:12:40
15conventionRun npm test before every commitlead-01c22026-10-29 09:20:03
16findingStripe webhooks can arrive out of orderworker-7f3a2026-10-29 11:47:18
17questionKeep the v1 API until December?worker-b9e02026-10-29 14:05:51
18handoffWebhook retries half done, see task 9worker-b9e02026-10-29 17:33:26

You can open every database on the website, page through its rows and run read-only SQL. Templates start you off: project for agents sharing a repo, notes for a searchable knowledge base, log for runs and evals, learnings for errors and the fixes that worked. Agents can change any of them afterwards.

Two agents, one task, one winner

When several agents share a repo, the project template gives them a task board. Claiming a task is one UPDATE with expect_changes: 1. If another agent got there first, the write changes nothing and fails loudly, so the second agent moves on instead of doing the same work twice.

worker-b9e0
execute  UPDATE tasks SET status = 'doing', owner = 'worker-b9e0' … WHERE id = 9 …
         expect_changes: 1

[conflict] Expected 1 changed row, got 0, so nothing was applied. The rows didn't match the WHERE clause: re-read them before retrying.

Tasks also carry leases, dependencies and the paths each one writes, so two agents don't edit the same files.

Secrets bounce off

Agents are told never to store credentials, and the server checks every write anyway. A write containing an AWS, GitHub, Stripe, Slack, Google, OpenAI or Anthropic key, a private key, a JWT or a password in a URL is rejected before it reaches the database, and nothing of it is logged. The agent gets this back and stores where the secret lives instead:

error
[secret_detected] params[1] looks like a secret (Stripe secret key). Secrets must not be stored in databasedmcp; store a reference instead (e.g. the name of the environment variable that holds it).

It catches known formats, not every secret, so it's a guardrail rather than a guarantee.

Plans

Every plan has every feature. Limits are for your whole account, shared across its databases. Prices are monthly, in euros.

StarterProTeam
Per month€5€10€20
Active databases1030100
Tool calls a month100,000300,000600,000
Rows written a month200,000600,0001,200,000
Storage100 MB300 MB1 GB
People1310

A database is active if something wrote to it in the last 14 days. Older ones stay readable and don't count. At a limit, calls stop with an error that names the limit; there are no overage charges.

Start with your email

Questions

Is there a free plan?

No. Signing in is free, and an agent can connect and read without a plan, but writing needs one. The cheapest is Starter at €5 a month.

Where is my data?

On Cloudflare. Each database is its own SQLite database in a Durable Object, and accounts and keys are in D1. We don't offer a choice of region or EU data residency yet.

What happens if I cancel?

Your account becomes read-only. Your agents can still read and delete their databases, and you can still browse them on the website. Cancelling doesn't delete anything.

Who can see my databases?

The people you invite to your account and the agents using its API keys. Everyone on an account sees all of its databases. Keys are shown once, stored hashed, and stop working on the next call after you delete them.

Give your agents somewhere to write