Saltar al contenido

Conecta Claude Code a Postgres por MCP sin permiso de borrar

En la práctica/ 20 min de lectura

Un rol de Postgres con GRANT SELECT, el servidor MCP configurado en Claude Code sin contraseñas en el repo y la prueba de que DELETE, UPDATE y DROP fallan.

  • Claude Code
  • Bases de datos
  • Seguridad
  • IA
En este artículo (9)
  1. Qué es un servidor MCP y qué hace con tu base
  2. El riesgo de darle acceso total a tu base
  3. Crear un rol de solo lectura con GRANT SELECT
  4. Configurar el servidor MCP de Postgres en Claude Code con ese rol
  5. Apuntarlo a una réplica, no a la base principal
  6. Probar que un DELETE se rechaza
  7. Errores comunes
  8. Preguntas frecuentes
  9. Checklist

Para conectar Claude Code a Postgres por MCP sin riesgo de que borre datos, crea un rol que solo tenga GRANT SELECT, ponlo en la cadena de conexión del servidor MCP y, si puedes, apúntalo a una réplica. El modo de solo lectura del servidor ayuda, pero quien rechaza el DELETE es Postgres.

Aquí tienes el SQL del rol, la configuración del servidor MCP para Claude Code sin contraseñas en el repo y la prueba de que un DELETE falla. Todo el SQL lo ejecutamos en PGlite 0.5.10, que es PostgreSQL 18.6 compilado a WebAssembly, y el servidor MCP lo probamos con un cliente simulado, sin ningún modelo de por medio.

Qué es un servidor MCP y qué hace con tu base

MCP (Model Context Protocol) es el protocolo con el que Claude Code se conecta a herramientas externas. Un servidor MCP es un programa que expone herramientas con nombre y parámetros; Claude Code decide cuándo llamarlas y recibe lo que devuelven. Los servidores locales corren como un proceso en tu computadora y hablan con Claude Code por stdio, la entrada y salida estándar, con mensajes JSON-RPC, como verás en la prueba del final.

Un servidor MCP para Postgres guarda la cadena de conexión y ofrece una herramienta para ejecutar SQL. En DBHub, el servidor que usamos aquí, esa herramienta se llama execute_sql: Claude escribe la consulta, el servidor la ejecuta con el usuario de la cadena de conexión y le devuelve las filas. Claude Code nunca abre la conexión. Lo que pueda pasar en tu base depende de ese usuario.

La documentación de MCP de Claude Code usa justo DBHub como ejemplo para consultar PostgreSQL, y pide usar un usuario de solo lectura en la cadena de conexión para que las consultas de Claude no puedan modificar datos. La misma página avisa que verifiques que confías en cada servidor antes de conectarlo, porque los que traen contenido externo te exponen a prompt injection. En una tienda, la reseña de un producto o la nota de un pedido es texto que escribió alguien de fuera, y cuando Claude la lee, entra en su contexto.

Claude Code no toca Postgres: le pide el SQL a un servidor MCPClaude Codeescribe el SQLllama a execute_sqlservidor MCPDBHub 1.6.1readonly = truePostgresréplicarol mcp_readonlystdio · JSON-RPCDSN = MCP_PG_DSNun DELETE en cada capapuede pedir cualquier SQLfiltro + BEGIN READ ONLYpor defecto: readonly = falsepermission deniedla frontera reallos privilegios del rol deciden, no el promptprobado en local: cliente MCP simulado, DBHub 1.6.1 y PGlite 0.5.10

Desliza la figura para verla completa

El riesgo de darle acceso total a tu base

Lo más cómodo es copiar la cadena de conexión de tu aplicación en la configuración del servidor MCP. Ese usuario suele ser el dueño de las tablas, el que corre las migraciones, y puede hacer DELETE, TRUNCATE y DROP. Basta un WHERE mal escrito, una instrucción mal entendida o un texto inyectado en una fila para que Claude ejecute algo que no querías, con permiso de sobra para hacerlo.

Una respuesta habitual es hacer que el servidor sea de solo lectura. El servidor de referencia, @modelcontextprotocol/server-postgres, ejecutaba cada consulta dentro de una transacción de solo lectura, según su README. Su repositorio se archivó el 29 de mayo de 2025, y en npm la versión 0.6.2 está marcada como obsoleta con el aviso «Archived and unmaintained; no security guarantees» (página del paquete).

El 21 de agosto de 2025, Datadog Security Labs publicó cómo saltarse esa protección. El cliente de Node que usaba el servidor acepta varias sentencias separadas por punto y coma, así que una consulta que empieza con COMMIT; cierra la transacción de solo lectura y lo que sigue corre con todos los permisos del usuario. Según el mismo artículo, el arreglo quedó en el repositorio pero no se publicó en npm, y su recomendación incluye usar un usuario de Postgres con privilegios restringidos.

Lo reprodujimos en PGlite con la misma secuencia: abrir BEGIN TRANSACTION READ ONLY, mandar la consulta entera y cerrar con ROLLBACK. Con el superusuario, COMMIT; DELETE FROM throwaway; dejó la tabla vacía. Con el rol de este artículo, COMMIT; SET default_transaction_read_only = off; DELETE FROM orders; respondió permission denied for table orders y las filas siguieron ahí.

Tampoco basta con default_transaction_read_only. La documentación de PostgreSQL lo describe como el estado por defecto de cada transacción nueva, y la de SET TRANSACTION explica que esos valores por defecto se cambian con SET y que cada transacción puede sobrescribirlos. En nuestra prueba, con ese parámetro en on, el rol recibió cannot execute DELETE in a read-only transaction; tras un SET default_transaction_read_only = off desde la misma sesión, al DELETE ya solo lo frenó el permiso.

DBHub, que sí se mantiene, aplica dos capas cuando activas readonly = true: un filtro de palabras clave y la ejecución dentro de BEGIN READ ONLY. Pero readonly vale false por defecto y solo se configura en su archivo TOML, y el ejemplo de la documentación de Claude Code solo pasa --dsn: ahí la única barrera es el usuario. La documentación de execute_sql lo dice sin rodeos: conecta siempre DBHub con un usuario de mínimo privilegio y solo lectura, y no apuntes una herramienta de solo lectura a un DSN de administrador confiando solo en ese modo.

CapaQué bloqueaCómo se salta
Transacción de solo lectura del servidor archivadoEscrituras dentro de esa transacciónCOMMIT; al inicio de la consulta (Datadog; reproducido en PGlite)
default_transaction_read_only = onEscrituras en cada transacción nuevaSET default_transaction_read_only = off desde la propia sesión (probado)
readonly = true en DBHubSentencias fuera de su lista (select, with, explain, show), y ejecuta en BEGIN READ ONLYNo lo saltamos; viene apagado y su documentación pide igual un usuario mínimo
Privilegios del rolTodo lo que no tenga un GRANTSolo un rol con más privilegios puede dárselos

Por eso el orden de este artículo: primero el rol, luego el servidor.

Crear un rol de solo lectura con GRANT SELECT

Este es role.sql, el mismo archivo que cargamos en las pruebas. Ejecútalo con un usuario que pueda crear roles y cambia app_owner por el rol dueño de tus tablas:

CREATE ROLE mcp_readonly WITH LOGIN CONNECTION LIMIT 3;

GRANT USAGE ON SCHEMA public TO mcp_readonly;
GRANT SELECT ON ALL TABLES IN SCHEMA public TO mcp_readonly;

ALTER DEFAULT PRIVILEGES FOR ROLE app_owner IN SCHEMA public
  GRANT SELECT ON TABLES TO mcp_readonly;

ALTER ROLE mcp_readonly SET default_transaction_read_only = on;
ALTER ROLE mcp_readonly SET statement_timeout = '10s';
  1. CREATE ROLE ... WITH LOGIN crea un rol que puede iniciar sesión, y según la documentación de CREATE ROLE, CONNECTION LIMIT fija cuántas conexiones simultáneas puede abrir. Por defecto no es superusuario ni puede crear bases o roles; la prueba lo confirmó en pg_roles.
  2. GRANT USAGE ON SCHEMA public le deja acceder a los objetos del esquema. Según la documentación de esquemas, en public todos los roles ya tienen ese permiso por defecto; en cualquier otro esquema, sin él no llega a ninguna tabla.
  3. GRANT SELECT ON ALL TABLES IN SCHEMA public le da lectura sobre las tablas que existen hoy. La documentación de GRANT aclara que ALL TABLES también cubre vistas y tablas foráneas.
  4. ALTER DEFAULT PRIVILEGES FOR ROLE app_owner hace que las tablas que app_owner cree después también se puedan leer. No toca las que ya existen.
  5. Los dos ALTER ROLE ... SET ponen valores por defecto en cada sesión del rol: transacciones de solo lectura y un límite de 10 segundos por sentencia. Son una red extra, no la barrera.

Falta la contraseña, y no la escribas dentro del SQL. La documentación de CREATE ROLE advierte que una contraseña en el comando viaja en texto plano y puede quedar en el historial del cliente o en el log del servidor, y menciona el comando \password de psql para cambiarla de forma segura. Conéctate con psql como administrador y ejecuta \password mcp_readonly.

Con el rol creado, ejecutamos cada sentencia como mcp_readonly sobre una tabla orders que pertenece a app_owner. Estos son los mensajes que devolvió PostgreSQL 18.6:

SentenciaRespuesta
SELECT count(*) FROM orders2 filas
DELETE FROM orderspermission denied for table orders
UPDATE orders SET total = 0permission denied for table orders
INSERT INTO orders VALUES (3, 'x@example.com', 1)permission denied for table orders
TRUNCATE orderspermission denied for table orders
DROP TABLE ordersmust be owner of table orders
ALTER TABLE orders ADD COLUMN note textmust be owner of table orders
CREATE TABLE scratch (id int)permission denied for schema public

DROP y ALTER fallan por otra razón: según la documentación de privilegios, el derecho a modificar o destruir un objeto es inherente a ser su dueño y no se puede otorgar, y el rol no es dueño de nada. CREATE TABLE falla porque desde PostgreSQL 15 el esquema public ya no deja crear objetos a cualquier rol. Si tu base viene de una versión anterior, la documentación de esquemas indica ejecutar REVOKE CREATE ON SCHEMA public FROM PUBLIC.

lo que el rol mcp_readonly puede hacer en Postgres, y lo que nosentenciarespuesta de PostgresSELECT count(*) FROM orders2 filasDELETE FROM orderspermission denied for table ordersUPDATE orders SET total = 0permission denied for table ordersINSERT INTO orders VALUES (…)permission denied for table ordersTRUNCATE orderspermission denied for table ordersDROP TABLE ordersmust be owner of table ordersALTER TABLE orders ADD COLUMN …must be owner of table ordersCREATE TABLE scratch (id int)permission denied for schema publicsolo SELECT pasa; el resto lo rechaza la basemensajes reales de PGlite 0.5.10 (PostgreSQL 18.6) con SET ROLE mcp_readonly

Desliza la figura para verla completa

Tablas nuevas y el rol de las migraciones

ALTER DEFAULT PRIVILEGES tiene una trampa. Según su documentación, al crear un objeto solo cuentan los privilegios por defecto del rol que lo crea. En la prueba, una tabla nueva de app_owner se pudo leer de inmediato; otra creada por un rol migrator respondió permission denied for table coupons. Pon en FOR ROLE el rol que corre tus migraciones, o repite la línea para cada rol que cree tablas.

Lo que probamos y lo que no

PGlite tiene una sola sesión, así que SET ROLE mcp_readonly hizo de inicio de sesión. Eso deja dos huecos. La documentación de ALTER ROLE dice que los valores por rol solo se aplican al iniciar sesión y que ni SET ROLE ni SET SESSION AUTHORIZATION los procesan: en la prueba, SHOW default_transaction_read_only devolvió off, así que esos dos ALTER ROLE no se probaron. Y con SET ROLE la sesión sigue siendo del superusuario; con SET SESSION AUTHORIZATION mcp_readonly, que se acerca más a un inicio de sesión real, SET ROLE postgres respondió permission denied to set role "postgres". Las 18 pruebas de role.test.mjs pasaron con node --test.

Configurar el servidor MCP de Postgres en Claude Code con ese rol

Usamos DBHub porque es el ejemplo de la documentación de Claude Code y porque se mantiene: su repositorio no está archivado y publicó tres versiones en noviembre de 2026, de la 1.5.1 a la 1.6.1. No lo comparamos con otros servidores. El rol funciona igual con cualquier servidor MCP de Postgres; lo que cambia es dónde se configura su modo de solo lectura.

DBHub solo acepta readonly en su archivo TOML. Su documentación de configuración dice que las opciones de las herramientas no se pueden pasar como flags, y la opción --readonly ya no existe: en su código, pasarla detiene el arranque con un error. Este es dbhub.toml, el mismo que cargamos en la prueba:

[[sources]]
id = "replica"
dsn = "${MCP_PG_DSN}"

[[tools]]
name = "execute_sql"
source = "replica"
readonly = true
max_rows = 200
  1. [[sources]] define la conexión. dsn = "${MCP_PG_DSN}" la lee de una variable de entorno al cargar el archivo, así que el TOML no lleva la contraseña y puede ir a git. Si la variable no existe, DBHub rechaza la fuente y nombra la variable que falta.
  2. [[tools]] configura execute_sql para esa fuente, y readonly = true activa el filtro y la transacción de solo lectura.
  3. max_rows = 200 recorta cada SELECT a 200 filas; si la consulta ya trae un LIMIT menor, gana el menor. Menos filas son menos datos de clientes en el contexto de Claude.

La variable MCP_PG_DSN lleva la cadena de conexión del rol, con esta forma: postgres://mcp_readonly:<contraseña>@<host-de-la-réplica>:5432/<base>?sslmode=require. Defínela en tu shell o tu gestor de secretos, nunca en un archivo del repo. Según la documentación de DBHub, sslmode=require cifra la conexión sin verificar el certificado, y verify-full también comprueba el certificado y el host. En nuestra prueba, con esa configuración el servidor expuso una sola herramienta, execute_sql.

Para registrarlo solo para ti, usa el alcance local, que es el que claude mcp add usa por defecto:

claude mcp add --env MCP_PG_DSN="$MCP_PG_DSN" --transport stdio postgres-ro \
  -- npx -y @bytebase/dbhub@1.6.1 --config /ruta/absoluta/dbhub.toml
  1. --env MCP_PG_DSN="$MCP_PG_DSN" pasa la variable al proceso del servidor; tu shell la expande al ejecutar el comando. La documentación avisa que si el nombre del servidor va justo después de --env, la CLI lo lee como otro par y lo rechaza, por eso --transport stdio va en medio.
  2. postgres-ro es el nombre con el que verás el servidor en /mcp. Sin --scope, Claude Code lo guarda en ~/.claude.json bajo la ruta del proyecto, con el valor ya expandido: no va a git, pero ese archivo guarda la contraseña y hay que tratarlo como un secreto.
  3. Todo lo que va después de -- llega al servidor sin cambios. npx -y descarga y ejecuta @bytebase/dbhub fijado en 1.6.1, para que una versión nueva no cambie el comportamiento sin que la revises; DBHub pide Node 22.5 o superior y usa stdio por defecto.
  4. --config va con ruta absoluta porque la documentación de Claude Code no dice en qué carpeta arranca un servidor stdio, y DBHub busca ./dbhub.toml en la carpeta actual si no le indicas otra.

Para confirmar que arrancó, ejecuta /mcp en Claude Code: según la documentación, la fila del servidor debe mostrar una marca de verificación. Ese comando y el siguiente archivo no los ejecutamos: los comprobamos con claude mcp add --help de Claude Code 2.1.238 y con la documentación.

Si tu equipo quiere el mismo servidor, el alcance project lo guarda en .mcp.json, en la raíz del repo, y la documentación recomienda subir ese archivo a git. Por eso solo debe llevar referencias a variables:

{
  "mcpServers": {
    "postgres-ro": {
      "command": "npx",
      "args": ["-y", "@bytebase/dbhub@1.6.1", "--config", "${DBHUB_CONFIG}"],
      "env": {
        "MCP_PG_DSN": "${MCP_PG_DSN}"
      }
    }
  }
}
  1. command y args arrancan el mismo servidor que el comando anterior. ${DBHUB_CONFIG} es la ruta absoluta al TOML en la computadora de cada persona.
  2. env le pasa MCP_PG_DSN al servidor. Claude Code expande ${VAR} en command, args, env, url y headers, y acepta ${VAR:-valor} para dar un valor por defecto.
  3. Si una variable no está definida, la configuración carga igual: claude mcp list muestra un aviso y el servidor recibe el texto ${VAR} sin expandir. En sesiones interactivas, Claude Code pide aprobación antes de usar servidores de un .mcp.json; con claude -p los carga sin preguntar.

Nunca escribas la cadena de conexión con la contraseña en .mcp.json: ese archivo está hecho para compartirse. Si una contraseña llegó a un commit, cámbiala con \password, porque borrar el archivo no la saca del historial. Es la misma regla que explicamos en las variables NEXT_PUBLIC_ de Next.js y los secretos: lo que se sube al repo o al navegador deja de ser secreto.

dónde vive cada pieza de la configuración MCP de Postgrespiezaqué llevadónde vive¿a git?role.sqlGRANT SELECT, sin escrituratus migracionessídbhub.tomlreadonly = true · max_rowsel proyectosí.mcp.json${VAR}, nunca valoresraíz del reposí~/.claude.jsonclaude mcp add (local)tu carpeta homenoMCP_PG_DSNusuario, contraseña, hostshell o gestornuncael repo guarda referencias, nunca la contraseñaClaude Code expande ${VAR} en command, args, env, url y headers

Desliza la figura para verla completa

Apuntarlo a una réplica, no a la base principal

El rol impide escribir, pero no impide leer de más. Una consulta sin índice sobre la tabla de pedidos compite por CPU y disco con tu checkout si corre en la base principal. En una réplica, esa carga cae en otro servidor, y la réplica añade su propia barrera: la documentación de hot standby dice que ahí transaction_read_only siempre vale true y no se puede cambiar, y que INSERT, UPDATE, DELETE, TRUNCATE, el DDL y GRANT dan error.

Antes de apuntar el servidor a la réplica, conviene saber tres cosas:

  • El rol se crea en la primaria. En un standby, CREATE y GRANT dan error. Con replicación física, el rol y sus permisos llegan a la réplica junto con lo demás.
  • Los datos llegan con retraso. La documentación lo llama consistencia eventual: la misma consulta en la primaria y en la réplica, casi al mismo tiempo, puede dar resultados distintos. Tenlo en cuenta si revisas un pedido de hace un segundo.
  • Las consultas largas se pueden cancelar. Si una consulta choca con los cambios que la réplica aplica, Postgres la cancela al superar max_standby_streaming_delay. hot_standby_feedback evita parte de esos conflictos a cambio de retrasar la limpieza de filas muertas en la primaria, lo que puede inflar las tablas.

Si no tienes réplica, el mismo rol sirve en la base principal, y ahí pesan más el statement_timeout del rol y el max_rows de DBHub. No probamos una réplica: PGlite no tiene replicación, así que esta sección se apoya solo en la documentación.

Probar que un DELETE se rechaza

La prueba de punta a punta usa la misma cadena que tendrás en Claude Code, con un cliente MCP simulado en lugar del modelo. Un script de Node habla JSON-RPC por stdio con DBHub 1.6.1, y DBHub se conecta a PGlite en 127.0.0.1 con pglite-socket, con la sesión como mcp_readonly. Llamamos a execute_sql con el TOML de arriba y con el mismo TOML sin readonly. Esta es la salida, resumida:

== dbhub-readonly.toml · DBHub MCP Server 1.6.1
> SELECT current_user, session_user, count(*) AS orders FROM orders
  "current_user": "mcp_readonly", "session_user": "mcp_readonly", "orders": "2"
> DELETE FROM orders
  READONLY_VIOLATION: Read-only mode is enabled. Only the following SQL operations are allowed: select, with, explain, show
> COMMIT; DELETE FROM orders
  READONLY_VIOLATION (el mismo mensaje)
== dbhub-default.toml (sin readonly)
> DELETE FROM orders
  EXECUTION_ERROR: permission denied for table orders
> COMMIT; DELETE FROM orders
  EXECUTION_ERROR: permission denied for table orders
rows left in orders: 2
  1. El SELECT funciona y confirma quién consulta: current_user y session_user son mcp_readonly.
  2. Con readonly = true, DBHub rechaza el DELETE y el COMMIT; DELETE antes de que lleguen a Postgres, con el código READONLY_VIOLATION.
  3. Sin readonly, que es como queda DBHub si solo le pasas --dsn, las dos consultas llegan a Postgres y el rol las rechaza.
  4. Al final, orders conserva sus dos filas.

Lo que esta prueba no cubre: Claude Code no participó. No ejecutamos claude mcp add, no tocamos ningún .mcp.json y no hubo llamadas a un modelo. Además, como PGlite tiene una sola sesión, la cambiamos a mcp_readonly con SET SESSION AUTHORIZATION antes de abrir el socket.

La prueba en tu base

Con psql y la misma variable puedes repetir la parte del rol contra tu base. Este es probe.sql, que también corrimos en PGlite. Cambia orders por una de tus tablas:

SHOW default_transaction_read_only;
SET default_transaction_read_only = off;
SELECT current_user, session_user;
SELECT rolsuper, rolcreaterole, rolcreatedb, rolbypassrls FROM pg_roles WHERE rolname = current_user;
SELECT count(*) AS owned_tables FROM pg_tables WHERE tableowner = current_user;
DELETE FROM orders WHERE false;
UPDATE orders SET total = total WHERE false;
INSERT INTO orders SELECT * FROM orders WHERE false;
  1. SHOW debe decir on en una conexión real: confirma que el ALTER ROLE ... SET se aplicó al iniciar sesión. En PGlite dijo off, por lo que explicamos arriba.
  2. El SET apaga ese valor solo en esta sesión. Sin él, cada escritura falla con cannot execute DELETE in a read-only transaction antes de revisar permisos, y no sabrías si el rol está bien.
  3. Las tres consultas siguientes deben mostrar mcp_readonly, cuatro false y 0 tablas propias.
  4. Cada escritura lleva WHERE false: no toca ninguna fila aunque el rol estuviera mal configurado, y aun así Postgres revisa los permisos. En la prueba, las tres respondieron permission denied for table orders.

Ejecútalo con psql "$MCP_PG_DSN" -f probe.sql; psql sigue con la siguiente sentencia cuando una falla. Hazlo una vez contra la primaria: en la réplica, las escrituras fallan siempre por ser de solo lectura y no verías el permiso. Después, en Claude Code, pídele que ejecute DELETE FROM orders WHERE false con la herramienta de Postgres y que te muestre el error exacto. Con readonly = true deberías ver READONLY_VIOLATION, como en nuestra prueba.

Errores comunes

  • Usar el usuario de la aplicación. Si el DSN lleva al dueño de las tablas, cualquier modo de solo lectura del servidor es lo único entre Claude y un DROP.
  • Confiar solo en el servidor. El servidor archivado se saltaba con COMMIT;, default_transaction_read_only se apaga con un SET y el readonly de DBHub viene en false. La barrera son los privilegios del rol.
  • Olvidar FOR ROLE. Sin él, las tablas que cree tu rol de migraciones no se pueden leer, y la tentación es darle más permisos al rol de MCP.
  • Funciones SECURITY DEFINER. PostgreSQL da EXECUTE a PUBLIC en funciones por defecto. En la prueba, una función SECURITY DEFINER de app_owner que borra pedidos corrió desde mcp_readonly y borró una fila. Tras REVOKE EXECUTE ON FUNCTION purge_orders() FROM PUBLIC, respondió permission denied for function purge_orders; dentro de BEGIN READ ONLY, falló con cannot execute DELETE in a read-only transaction. Revisa las tuyas.
  • La contraseña en .mcp.json. Usa ${VAR} y define las variables fuera del repo.
  • --env justo antes del nombre. claude mcp add --env A=1 postgres-ro ... falla; pon --transport stdio entre los dos.
  • Dar lectura a todo. GRANT SELECT ON ALL TABLES incluye clientes, correos y direcciones. Y la documentación de GRANT avisa que revocar una columna después de dar la tabla entera no hace lo que esperas: el permiso de la tabla sigue.

Preguntas frecuentes

¿Puedo usar pg_read_all_data en vez de GRANT SELECT?

Sí, desde PostgreSQL 14. Según la documentación de roles predefinidos, pg_read_all_data lee todas las tablas, vistas y secuencias, con USAGE en todos los esquemas, y no salta las políticas de seguridad por fila. Es más amplio que GRANT SELECT sobre un esquema: úsalo solo si de verdad quieres que Claude lea todo.

¿No basta con el modo de solo lectura de DBHub?

Es una buena segunda capa: en nuestra prueba rechazó el DELETE antes de llegar a Postgres. Pero viene apagado, vive en un archivo que alguien puede cambiar y su propia documentación pide un usuario de mínimo privilegio. El rol te protege aunque cambies de servidor o de configuración.

¿Y si no tengo réplica?

Usa el mismo rol en la base principal, con statement_timeout y CONNECTION LIMIT bajos y max_rows en DBHub. Lo que pierdes es la separación de carga: una consulta pesada que escriba Claude corre en el mismo servidor que tu tienda.

¿Claude puede ver datos personales de mis clientes?

Sí, todo lo que el rol pueda leer puede terminar en el contexto de Claude. Si no lo necesita, no se lo des: otorga SELECT por tabla o por columna en vez de ALL TABLES, o crea vistas sin esas columnas en un esquema aparte y da permiso solo sobre ese esquema.

Checklist

  • El servidor MCP usa un rol propio, no el usuario de la aplicación ni el de las migraciones.
  • El rol tiene USAGE en el esquema y SELECT en las tablas que hacen falta, nada más.
  • ALTER DEFAULT PRIVILEGES FOR ROLE apunta al rol que crea tus tablas.
  • La contraseña se puso con \password y vive solo en MCP_PG_DSN, fuera del repo.
  • dbhub.toml tiene readonly = true y max_rows, y la versión del servidor está fijada.
  • .mcp.json solo tiene referencias ${VAR}.
  • El DSN apunta a una réplica, o a la primaria con statement_timeout bajo.
  • probe.sql da permission denied en las tres escrituras y 0 tablas propias.
  • Las funciones SECURITY DEFINER que escriben no tienen EXECUTE para PUBLIC.

Con el rol en su lugar, el servidor MCP puede equivocarse o cambiar y tu base sigue igual. Si además quieres que Claude Code no lea tus archivos de entorno, mira el hook que protege tu .env en Claude Code, y repasa qué variables de Next.js nunca deben llevar secretos. Si tu tabla de trabajos vive en la misma base, la cola de trabajos en Postgres con SKIP LOCKED es un buen lugar para probar el rol.

¿Viste esto en Instagram? Comenta MCP en el Reel y te mando la guía.

Escrito por

Luis Morales

Luis Morales

Desarrollador frontend y Shopify, EcomLabs

@luismoralesdev en Instagram

Publicado el 11 de noviembre de 2026

← Blog