Acceso MCP a bases de datos para agentes de IA: cómo Claix Retrieve y Guard añaden el control que MCP no tiene

Lo esencial, de un vistazo

Qué es MCP, y qué no es

MCP es un protocolo abierto que permite a una aplicación de IA (el cliente) descubrir y llamar a las herramientas que expone un servidor. Resuelve un problema real de integración: en lugar de escribir un conector a medida para cada herramienta y cada modelo, escribes un servidor y cualquier cliente compatible puede usarlo.

Lo que MCP no hace es decidir qué puede hacer el agente con una herramienta. Estandariza la llamada, no la política. Piénsalo como una línea de teléfono mejor hacia tu base de datos. La línea es más clara y más cómoda, pero nadie en ella decide qué preguntas se pueden hacer ni qué cambios se pueden aplicar.

Qué le da a tu agente un servidor MCP de base en bruto

Un servidor MCP de base típico expone herramientas como list_tables, describe_table y execute_sql. Eso es estupendo para quien desarrolla: un asistente puede explorar un esquema, probar una consulta y proponer una migración en segundos.

Pon el mismo servidor delante de un agente que trabaja con datos reales de clientes y el panorama cambia:

• El modelo escribe el SQL. Lo que escriba se ejecuta con los permisos del rol de la base.
• El único freno es el rol. Un rol de solo lectura es una buena base, pero no es una política completa. Datadog Security Labs publicó un caso de inyección SQL en el servidor MCP de PostgreSQL en el que un COMMIT dentro de la entrada dejó escapar una consulta de la transacción de solo lectura en la que se apoyaba el servidor.
• No hay reglas de negocio. Un rol puede decir quién puede actualizar una tabla. No puede decir que un descuento no supere el 20 por ciento o que una sentencia no cambie más de cinco filas.
• Cada agente redescubre el esquema en cada conversación, lo que gasta tokens e invita a errores.

Esto no es un defecto del protocolo. Es lo que es un conector: una puerta, sin nadie que decida qué ocurre detrás.

Por qué MCP más un agente que escribe SQL, o las salidas estructuradas, siguen dejando huecos

Hay tres patrones habituales encima de un servidor MCP en bruto: dejar que el agente principal escriba SQL, añadir un subagente dedicado que genere SQL, u obligar a la respuesta a seguir un esquema JSON con salidas estructuradas. Ayudan, y cada uno deja los mismos huecos.

• Las salidas estructuradas garantizan la forma de una respuesta, no su verdad. Una respuesta puede ser JSON perfectamente válido y aun así contener un número inventado, porque se obligó al modelo a rellenar un campo y el dato no estaba. Tampoco dicen si una sentencia es segura de ejecutar.
• Un agente que escribe mejor SQL sigue siendo un modelo que decide qué ejecutar. Un prompt más cuidadoso o un segundo modelo reducen errores, pero ambos son probabilísticos. Una comprobación que tiene que cumplirse siempre tiene que vivir fuera del modelo.
• Ninguno de los dos patrones te da límites por agente, un interruptor de parada ni una traza de auditoría. Eso son funciones de operación, no del modelo.

Cómo funciona Claix Retrieve con MCP

Claix Retrieve se conecta a una base SQL (PostgreSQL, MySQL, MariaDB o Supabase) con un rol de solo lectura. Tú decides qué tablas, columnas y relaciones puede usar cada agente, con una guía breve escrita en tu vocabulario. Claix redacta un Data Map del esquema para que lo revises, y ese mapa se comparte entre tus agentes.

Tu agente llega a Retrieve por MCP (la herramienta es claix.retrieve.ask), REST o A2A. La diferencia con un servidor de base en bruto está en lo que el agente envía y en lo que recibe:

Como Retrieve es un servidor MCP, adoptarlo no cambia cómo se conecta tu agente. Cambias una herramienta por otra.

Dónde un servidor MCP en bruto sigue siendo la mejor opción

Ser honesto aquí importa. Un servidor MCP en bruto es la mejor herramienta para desarrollar, para explorar un esquema desconocido, para un análisis puntual y para los casos en los que quieres que el modelo escriba cualquier consulta. Es gratis, flexible y no añade otra pieza. Retrieve es para el momento en que un agente empieza a actuar de verdad sobre datos de producción y usuarios reales.

Cómo funciona Claix Guard como la comprobación antes de execute_sql

Si tu agente tiene que escribir en la base a través de una herramienta MCP, el sitio más seguro para añadir control es el único punto en el que una sentencia está a punto de ejecutarse. Claix Guard es un comprobador de reglas exactamente para ese momento.

• Describes tus reglas en lenguaje natural, por ejemplo: Los descuentos no pueden superar el 20 por ciento. Los agentes no pueden borrar pedidos. Ninguna sentencia puede cambiar más de cinco filas.
• Claix las convierte en reglas exactas con casos de prueba, y tú las revisas, las aceptas o las editas.
• Antes de que la sentencia se ejecute, tu código se la envía a Guard y recibe permitir o denegar, con el motivo.
• Ningún modelo de IA decide en el momento de la comprobación, y Claix nunca ejecuta la sentencia. Lo hace tu código.

Agente -> propone SQL -> tu wrapper -> POST /check-sql (Claix Guard)
                                   |- permitido -> MCP execute_sql -> base de datos
                                   |- denegado  -> el motivo vuelve al agente

Este es el patrón en Python. Al agente se le da guarded_execute_sql como herramienta, y el execute_sql en bruto no se le expone:

import os
import httpx

CLAIX_HEADERS = {'x-api-key': os.environ['CLAIX_API_KEY']}

async def guarded_execute_sql(mcp_session, sql: str):
    # 1. Pregunta primero a Guard. Una sentencia por comprobación.
    async with httpx.AsyncClient(timeout=10) as http:
        resp = await http.post(
            'https://claix.dev/check-sql',
            headers=CLAIX_HEADERS,
            json={'sql': sql},
        )
    resp.raise_for_status()  # cualquier error significa fallar cerrado
    verdict = resp.json()

    # 2. Solo un allow explícito llega al servidor MCP de la base.
    if not verdict['allowed']:
        return 'Blocked by Claix Guard: ' + verdict['reason']

    # 3. Reenvía exactamente la sentencia que se comprobó.
    return await mcp_session.call_tool('execute_sql', {'query': sql})

El nombre del argumento (query en este ejemplo) depende del servidor MCP que uses. Una respuesta denegada tiene esta forma (los valores son marcadores):

{
  "allowed": false,
  "decision_id": "<uuid>",
  "code": "<code>",
  "reason": "<why the statement was denied>",
  "operation": "delete",
  "table": "orders",
  "violations": [{ "guard_name": "<guard>", "rule_title": "<rule>", "message": "<message>" }],
  "rules_checked": 3,
  "latency_ms": 0
}

Como el motivo está escrito en lenguaje natural, el agente puede leerlo y proponer otro cambio en lugar de fallar con un error críptico de la base.

Reglas para usar Guard con seguridad

• Que sea el único camino. Guard decide y tu código hace cumplir. Si el agente todavía puede llegar a un execute_sql en bruto, la comprobación se puede saltar. Expón solo la herramienta protegida.
• Falla cerrado. Si la llamada falla, agota el tiempo o devuelve cualquier cosa que no sea un permitir explícito, no ejecutes la sentencia.
• Comprueba exactamente lo que ejecutas. Envía la misma sentencia que reenvías, y rechaza una entrada con más de una sentencia.
• Trata como denegado todo lo que no esté permitido de forma explícita, incluidos tipos de sentencia que no esperabas.
• Mantén igual de ajustados los permisos de la base. Guard es una capa adicional, no un sustituto del mínimo privilegio.

Cómo encaja: lecturas por Retrieve, escrituras por Guard

El mismo principio recorre todo: MCP es la puerta, y Claix decide qué hay detrás.

Precio

Cada cuenta tiene 30 llamadas correctas al mes gratis. Retrieve cuesta 0,10 € por pregunta con la IA gestionada de Claix, o 0,02 € con tu propia clave de LLM (los tokens los pagas a tu proveedor). Guard cuesta 0,01 € por comprobación. Solo pagas las llamadas correctas (HTTP 200); los errores de autenticación, las peticiones inválidas y los errores del servidor son gratis.

Conclusión

MCP hizo fácil conectar agentes con datos, y por eso el control importa más, no menos. Un servidor MCP de base en bruto es una llamada de teléfono mejor a tu base; no es una política. Usa Claix Retrieve cuando un agente deba leer datos en vivo sin escribir SQL, y pon Claix Guard delante de execute_sql cuando tenga que cambiar datos. Conserva el servidor MCP en bruto para desarrollo, y deja que el agente de producción trabaje detrás de una capa que dice sí o no, con el motivo.

Prueba Claix gratis: 30 llamadas correctas al mes. Empieza en https://www.claix.dev/es/register.