Scribase

npx add-mcp 'https://api.scribase.com/mcp'

O backend que um agente não consegue destruir

O scribase-mcp dá ao Claude Code, Cursor e qualquer cliente MCP 44 ferramentas sobre seus projetos Scribase. Leituras são executadas imediatamente; toda escrita aguarda uma confirmação explícita, e mudanças de schema devem passar por um teste de isolamento RLS primeiro.

Servidor

scribase-mcp

Transporte

stdio, ou HTTP streamable em /mcp

Plano de controle

https://api.scribase.com

Autenticação

Token de acesso pessoal ou chave de API da organização, auditado por chamada

Mutações precisam de confirmação

Toda ferramenta que altera algo recusa sem confirm: true e retorna a requisição exata que enviaria, para que um humano aprove aquela mudança específica.

RLS é comprovado antes de ser publicado

schema.apply só aceita um token de policy.test, que comprova a matriz de isolamento e depois quebra cada garantia de propósito para mostrar que a prova pode falhar.

Mudanças chegam primeiro em uma prévia

Branches de prévia são cópias de produção com varredura TTL e dados sanitizados. Merges são seguros para chaves estrangeiras e precedidos por um backup.

Conectar

Instale uma vez, depois adicione ao seu editor

Crie um token de agente com escopo no console em Account, Tokens. Dê a ele apenas as organizações que o agente deve ver.

Instalaçãobash

# Remote: nothing to install. Use the URL below with a personal
# access token (scb_pat_) or organization API key (sbk_).

# Local instead: build the server from the Scribase repository (Rust 1.85+)
cargo install --path crates/mcp

# Over stdio your editor starts it; \`scribase-mcp serve --http :8787\`
# serves the same tools remotely (needs SCRIBASE_API_URL).
# Schema tools run on a scratch Postgres the server starts itself
# (initdb, pg_ctl and psql on PATH), or on the cluster in PGHOST if set.
# Control-plane tools use SCRIBASE_API_URL and SCRIBASE_ACCESS_TOKEN.

Claude Codebash

claude mcp add --transport http scribase https://api.scribase.com/mcp \
  --header "Authorization: Bearer $SCRIBASE_ACCESS_TOKEN"

Cursor (.cursor/mcp.json)json

{
  "mcpServers": {
    "scribase": {
      "url": "https://api.scribase.com/mcp",
      "headers": {
        "Authorization": "Bearer ${env:SCRIBASE_ACCESS_TOKEN}"
      }
    }
  }
}

Configuração passo a passo com o arquivo de regras e um primeiro prompt: Claude Code, Codex, Cursor, Windsurf e VS Code.

Ferramentas

44 ferramentas, agrupadas pelo que elas tocam

Schema e política

Executadas em uma branch temporária de propriedade da sessão. schema.apply só aceita um token que policy.test (ou policy.simulate) emitiu para exatamente o mesmo schema, então uma política não comprovada não pode ser aplicada.

schema.propose	Analisar e planejar uma mudança de schema sem aplicá-la.	leitura
policy.simulate	Aplicar em uma branch temporária e executar a matriz de isolamento entre usuários. Emite um token de aplicação em caso de aprovação.	leitura
policy.test	O harness de mutação Aegis: comprovar isolamento, depois quebrar cada garantia em branches descartáveis e exigir que cada quebra seja detectada. Emite um token de aplicação em caso de aprovação.	leitura
schema.apply	Aplicar um schema que policy.test já comprovou, usando seu token.	precisa de confirmação
sql.explain	EXPLAIN uma declaração contra a branch da sessão.	leitura

Branches e prévias

Ambientes de prévia são branches de produção com varredura TTL e dados sanitizados.

environment.create	Criar um ambiente, incluindo uma prévia com TTL.	precisa de confirmação
environment.list	Listar ambientes em um projeto.	leitura
environment.get	Ler um ambiente e sua fase.	leitura
environment.delete	Excluir um ambiente.	precisa de confirmação
environment.suspend	Suspender um ambiente.	precisa de confirmação
environment.resume	Retomar um ambiente suspenso.	precisa de confirmação
branch.register	Registrar um ambiente como branch de uma base.	precisa de confirmação
branch.list	Listar branches e sua linhagem.	leitura
branch.diff	Diff de schema entre uma base e um ambiente head.	leitura
branch.merge	Mesclar uma branch head em sua base, seguro para chaves estrangeiras.	precisa de confirmação
branch.link_pull_request	Vincular uma branch a um pull request do GitHub, GitLab ou Bitbucket.	precisa de confirmação
operation.get	Consultar uma operação assíncrona até um estado terminal.	leitura

Dados e runtime

Visualizações somente leitura de um ambiente ativo.

database.tables	Listar tabelas com estimativas de linhas e estado RLS.	leitura
database.query	Executar uma consulta SQL somente leitura.	leitura
auth.users	Listar usuários de autenticação (sem segredos).	leitura
storage.buckets	Listar buckets de armazenamento.	leitura
functions.list	Listar funções implantadas.	leitura
logs.tail	Acompanhar logs recentes.	leitura
metrics.get	Ler métricas do ambiente.	leitura
insights.get	Consultores de segurança e desempenho.	leitura
usage.get	Uso em relação aos limites do plano.	leitura

Migrações, backups e portabilidade

Toda escrita é bloqueada por confirmação e auditada.

migrate.run	Planejar e verificar migrações; aplicar apenas com apply e confirm.	precisa de confirmação
backup.list	Listar backups.	leitura
backup.get	Ler um backup e suas evidências de verificação.	leitura
backup.create	Fazer um backup.	precisa de confirmação
backup.restore	Restaurar um backup em um ambiente de destino.	precisa de confirmação
import.supabase	Simular ou iniciar uma importação de projeto em segundo plano.	precisa de confirmação
import.status	Acompanhar uma importação em segundo plano: fase, contagens, erros, relatório.	leitura
export.run	Produzir um pacote de exportação portátil.	leitura

Organização e acesso

Gerenciamento de membros e chaves.

org.list	Listar organizações que o token pode ver.	leitura
org.get	Ler uma organização.	leitura
org.put	Criar ou atualizar uma organização.	precisa de confirmação
member.put	Definir um papel de membro.	precisa de confirmação
project.list	Listar projetos.	leitura
project.get	Ler um projeto.	leitura
project.put	Criar ou atualizar um projeto.	precisa de confirmação
apikey.list	Listar chaves de API (nunca seus valores).	leitura
apikey.revoke	Revogar uma chave de API.	precisa de confirmação
audit.list	Ler o log de auditoria.	leitura

Habilidade do Claude Code

Branch de prévia, testes RLS, confirmação humana, merge

Coloque esta habilidade em um projeto e o Claude Code seguirá o fluxo de mudança segura toda vez que tocar no seu schema: ele ensaia em uma prévia, comprova isolamento, mostra o diff e aguarda sua aprovação antes de mesclar.

Instalar em um projetobash

mkdir -p .claude/skills/scribase-safe-change
curl -fsSL https://scribase.com/mcp/skill -o .claude/skills/scribase-safe-change/SKILL.md

Ou baixe SKILL.md diretamente. Funciona apenas com o CLI e usa as ferramentas MCP quando o servidor está conectado.

Migrando um aplicativo existente primeiro? Veja o guia de migração.

.claude/skills/scribase-safe-change/SKILL.mdmd

---
name: scribase-safe-change
description: Ship a schema or row-level-security change to a Scribase project safely. Creates a preview branch, applies the migration there, proves RLS isolation with policy.test (the Aegis mutation harness), shows the diff, waits for explicit human confirmation, then merges and cleans up. Use whenever you add or change tables, columns, indexes, functions, or policies on Scribase.
---

# Scribase safe change: preview, test, confirm, merge

Never change production schema directly. Every change goes through this flow,
in order. If any step fails, stop and report; do not skip ahead.

Inputs you need: \`ORG\`, \`PROJECT\`, the project \`REGION\`, a short change
name \`CHANGE\` (for example \`add-invoices\`), and the migration files under
\`migrations/\`.
Credentials come from the environment only (\`SCRIBASE_API_URL\`,
\`SCRIBASE_ACCESS_TOKEN\`). Never print them.

## 1. Create a preview branch

A preview is a copy of production with sanitized data and a TTL, so a forgotten
preview deletes itself.

\`\`\`bash
PREVIEW="preview-$CHANGE"
scribase env create "$ORG" "$PROJECT" "$PREVIEW" preview sanitized "$REGION" "$PREVIEW" 24
scribase operation get "$ORG" "$OPERATION_ID"      # repeat until state is succeeded
scribase branch register "$ORG" "$PROJECT" "$PREVIEW" --base production
\`\`\`

With the MCP server: \`environment.create\` (kind \`preview\`, data mode
\`sanitized\`, TTL 24), then \`operation.get\` until it succeeds, then
\`branch.register\`. Both mutations need \`confirm: true\`; creating a
preview is safe to confirm yourself because it cannot touch production.

## 2. Apply the migration to the preview only

\`\`\`bash
scribase migrate "$ORG" "$PROJECT" "$PREVIEW" --dir migrations           # plan + lint
scribase migrate "$ORG" "$PROJECT" "$PREVIEW" --dir migrations --apply   # apply to the preview
\`\`\`

If the linter blocks a change (a lock-heavy ALTER, a dropped column still in
use), fix the migration. Do not force it.

## 3. Prove row level security

Every table that holds user data must have RLS enabled and policies that keep
user A out of user B's rows.

- MCP: call \`policy.test\` with the full schema source. It applies the
  schema to a scratch branch, runs the cross-user isolation matrix, then
  breaks each guarantee on purpose (FORCE removed, USING (true), a dropped
  WITH CHECK) on throwaway branches and requires every break to be caught.
  A pass returns an apply token; a failure lists every leak or missed mutant.
- CLI: run Aegis against the preview. \`--mutate\` breaks each policy on
  purpose and checks the tests notice, which proves the tests can fail.

\`\`\`bash
aegis compile aegis.yaml
aegis test
aegis test --mutate
scribase insights "$ORG" "$PROJECT" "$PREVIEW"   # advisors: missing RLS, unindexed FKs
\`\`\`

A single leak or a surviving mutation is a failure. Fix the policies and
return to step 2.

## 4. Show the change and wait for a human

\`\`\`bash
scribase branch diff "$ORG" "$PROJECT" production "$PREVIEW"
scribase branch merge "$ORG" "$PROJECT" production "$PREVIEW" --dry-run
\`\`\`

Present, in one message: the schema diff, the merge dry run, the RLS results
(simulate verdict, Aegis pass and mutation score), and any insights findings.
Then stop and ask for explicit approval to merge into production. Do not
treat silence, an earlier approval, or approval of a different change as
consent. With MCP, \`branch.merge\` without \`confirm\` returns the exact
request; show it and wait.

## 5. Merge after approval

\`\`\`bash
scribase backup create "$ORG" "$PROJECT" production "pre-$CHANGE"   # restore point
scribase branch merge "$ORG" "$PROJECT" production "$PREVIEW"
\`\`\`

With MCP: \`backup.create\` then \`branch.merge\` with \`confirm: true\`, only
after the human approved in step 4. Poll any returned operation with
\`operation.get\` until it reaches a terminal state. A 202 is not success.

## 6. Clean up and report

\`\`\`bash
scribase env delete "$ORG" "$PROJECT" "$PREVIEW" "$PREVIEW-delete"
\`\`\`

Report: the migration files applied, the RLS evidence, the backup id taken
before the merge, and the operation ids. If anything failed after the merge,
say so first and offer \`scribase restore start\` from the pre-merge backup.