Scribase

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

El backend que un agente no puede destruir

scribase-mcp le brinda a Claude Code, Cursor y cualquier cliente MCP 44 herramientas sobre tus proyectos de Scribase. Las lecturas se ejecutan de inmediato; cada escritura espera una confirmación explícita, y los cambios de esquema deben pasar una prueba de aislamiento RLS primero.

Servidor

scribase-mcp

Transporte

stdio, o HTTP transmisible en /mcp

Plano de control

https://api.scribase.com

Autenticación

Token de acceso personal o clave API de organización, auditado por llamada

Las mutaciones requieren confirmación

Toda herramienta que cambia algo se niega sin confirm: true y devuelve la solicitud exacta que enviaría, para que un humano apruebe ese cambio específico.

RLS se demuestra antes de implementarse

schema.apply solo acepta un token de policy.test, que demuestra la matriz de aislamiento y luego rompe cada garantía a propósito para mostrar que la prueba puede fallar.

Los cambios llegan primero a una vista previa

Las ramas de vista previa son copias de producción con barrido TTL y datos saneados. Las fusiones son seguras para claves foráneas y van precedidas de una copia de seguridad.

Conectar

Instala una vez, luego agrégalo a tu editor

Crea un token de agente con ámbito en la consola bajo Account, Tokens. Dale solo las organizaciones que el agente debe ver.

Instalaciónbash

# 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}"
      }
    }
  }
}

Configuración paso a paso con el archivo de reglas y un primer prompt: Claude Code, Codex, Cursor, Windsurf y VS Code.

Herramientas

44 herramientas, agrupadas por lo que tocan

Esquema y política

Se ejecutan en una rama de prueba propiedad de la sesión. schema.apply solo acepta un token que policy.test (o policy.simulate) emitió para el mismo esquema exacto, por lo que una política no probada no puede aplicarse.

schema.propose	Analizar y planificar un cambio de esquema sin aplicarlo.	lectura
policy.simulate	Aplicar a una rama de prueba y ejecutar la matriz de aislamiento entre usuarios. Emite un token de aplicación al pasar.	lectura
policy.test	El arnés de mutación Aegis: demostrar aislamiento, luego romper cada garantía en ramas desechables y exigir que cada ruptura sea detectada. Emite un token de aplicación al pasar.	lectura
schema.apply	Aplicar un esquema que policy.test ya demostró, usando su token.	necesita confirmación
sql.explain	EXPLAIN una declaración contra la rama de la sesión.	lectura

Ramas y vistas previas

Los entornos de vista previa son ramas de producción con barrido TTL y datos saneados.

environment.create	Crear un entorno, incluida una vista previa con un TTL.	necesita confirmación
environment.list	Listar entornos en un proyecto.	lectura
environment.get	Leer un entorno y su fase.	lectura
environment.delete	Eliminar un entorno.	necesita confirmación
environment.suspend	Suspender un entorno.	necesita confirmación
environment.resume	Reanudar un entorno suspendido.	necesita confirmación
branch.register	Registrar un entorno como rama de una base.	necesita confirmación
branch.list	Listar ramas y su linaje.	lectura
branch.diff	Diferencia de esquema entre una base y un entorno principal.	lectura
branch.merge	Fusionar una rama principal en su base, segura para claves foráneas.	necesita confirmación
branch.link_pull_request	Vincular una rama a una solicitud de extracción de GitHub, GitLab o Bitbucket.	necesita confirmación
operation.get	Consultar una operación asíncrona hasta un estado terminal.	lectura

Datos y tiempo de ejecución

Vistas de solo lectura de un entorno en vivo.

database.tables	Listar tablas con estimaciones de filas y estado de RLS.	lectura
database.query	Ejecutar una consulta SQL de solo lectura.	lectura
auth.users	Listar usuarios de autenticación (sin secretos).	lectura
storage.buckets	Listar buckets de almacenamiento.	lectura
functions.list	Listar funciones implementadas.	lectura
logs.tail	Seguir registros recientes.	lectura
metrics.get	Leer métricas del entorno.	lectura
insights.get	Asesores de seguridad y rendimiento.	lectura
usage.get	Uso contra los límites del plan.	lectura

Migraciones, copias de seguridad y portabilidad

Cada escritura está protegida por confirmación y auditada.

migrate.run	Planificar y verificar migraciones; aplicar solo con apply y confirm.	necesita confirmación
backup.list	Listar copias de seguridad.	lectura
backup.get	Leer una copia de seguridad y su evidencia de verificación.	lectura
backup.create	Tomar una copia de seguridad.	necesita confirmación
backup.restore	Restaurar una copia de seguridad en un entorno de destino.	necesita confirmación
import.supabase	Ejecución de prueba o iniciar una importación de proyecto en segundo plano.	necesita confirmación
import.status	Seguir una importación en segundo plano: fase, conteos, errores, informe.	lectura
export.run	Producir un paquete de exportación portátil.	lectura

Organización y acceso

Gestión de membresías y claves.

org.list	Listar organizaciones que el token puede ver.	lectura
org.get	Leer una organización.	lectura
org.put	Crear o actualizar una organización.	necesita confirmación
member.put	Establecer un rol de miembro.	necesita confirmación
project.list	Listar proyectos.	lectura
project.get	Leer un proyecto.	lectura
project.put	Crear o actualizar un proyecto.	necesita confirmación
apikey.list	Listar claves API (nunca sus valores).	lectura
apikey.revoke	Revocar una clave API.	necesita confirmación
audit.list	Leer el registro de auditoría.	lectura

Habilidad de Claude Code

Rama de vista previa, pruebas RLS, confirmación humana, fusión

Coloca esta habilidad en un proyecto y Claude Code seguirá el flujo de cambio seguro cada vez que toque tu esquema: ensaya en una vista previa, demuestra aislamiento, te muestra la diferencia y espera tu aprobación antes de fusionar.

Instalar en un proyectobash

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

O descarga SKILL.md directamente. Funciona solo con la CLI y usa las herramientas MCP cuando el servidor está conectado.

¿Moviendo una aplicación existente primero? Consulta la guía de migración.

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