de en es ja ko ru zh

MCP Autonomous Data Agent

Name: MCP Autonomous Data Agent
Author: fortuneMog

by fortuneMog

Overview Schema Related Servers Score Discussions

Python

Local

Anthropic Claude API & MCP Autonomous Data Agent

Python Version Protocol Test Suite Security

Un sistema financiero analítico de nivel empresarial y calidad de producción que integra el Anthropic Model Context Protocol (MCP) con un agente de razonamiento autónomo. El sistema expone de forma segura un almacén de datos financieros relacional de múltiples tablas a los grandes modelos de lenguaje (LLM) mediante el transporte estándar JSON-RPC 2.0 stdio.

Incluye una inteligente arquitectura de defensa en profundidad en 5 capas, un analizador AST SQL y analizador sintáctico descendente recursivo en Python puro, un analizador de rendimiento de planes EXPLAIN, un pool de conexiones seguro para hilos con tiempos de espera de ejecución de opcodes y un bucle de autocuración del agente autónomo capaz de recuperarse automáticamente de errores de sintaxis SQL, violaciones de seguridad del AST y advertencias de combinaciones cartesianas.

Descripción general de la arquitectura

┌─────────────────────────────────────────────────────────────────────────────┐
│                          Stakeholder / User Prompt                          │
│               ("Identify branches with elevated 60+ delinquency")            │
└──────────────────────────────────────┬──────────────────────────────────────┘
                                       │
                                       ▼
┌─────────────────────────────────────────────────────────────────────────────┐
│                 Autonomous Agent Runner (agent/client_runner.py)            │
│  - Multi-Turn Tool-Calling Loop (Anthropic Claude API / MockClaudeClient)   │
│  - Schema-First Reflection & Planning                                       │
│  - Closed-Loop Self-Correction & Query Repair Engine (Max Turns: 5)         │
└──────────────────────────────────────┬──────────────────────────────────────┘
                                       │ JSON-RPC 2.0 (stdio)
                                       ▼
┌─────────────────────────────────────────────────────────────────────────────┐
│                      MCP Server Engine (agent/server.py)                    │
│  ┌───────────────────────────────────────────────────────────────────────┐  │
│  │ Methods: initialize, ping, tools/list, tools/call, resources, prompts │  │
│  └───────────────────────────────────┬───────────────────────────────────┘  │
│                                      │                                      │
│      ┌───────────────────────────────┼───────────────────────────────┐      │
│      ▼                               ▼                               ▼      │
│  query_database               explain_query                 get_database_   │
│  (query_financial_lakehouse)                                schema          │
└──────┬───────────────────────────────┬───────────────────────────────┬──────┘
       │                               │                               │
       ▼                               ▼                               ▼
┌─────────────────────────┐ ┌─────────────────────────┐ ┌─────────────────────┐
│ Layer 1: AST Gate       │ │ Layer 2: Plan Analyzer  │ │ Layer 3: Connection │
│ (agent/ast_validator.py)│ │(agent/explain_analyzer) │ │ Pool & Sandboxing   │
│ - Pure Python Lexer     │ │ - Cost Scoring (0-100)  │ │ (agent/db_engine.py)│
│ - Recursive AST Parser  │ │ - Full Scan Detection   │ │ - URI mode=ro       │
│ - 100% Non-DQL Block    │ │ - Cartesian Join Flag   │ │ - sqlite authorizer │
│ - Injection Defense     │ │ - Index Tuning Advice   │ │ - Opcode Timeouts   │
└────────────┬────────────┘ └────────────┬────────────┘ └──────────┬──────────┘
             │                           │                         │
             └───────────────────────────┼─────────────────────────┘
                                         ▼
                 ┌───────────────────────────────────────────────┐
                 │  Financial Data Warehouse (data/warehouse.db) │
                 │  - 6 Relational Tables & Composite Indexes    │
                 │  - branches, customers, credit_ratings,       │
                 │    loans, repayments, audit_log               │
                 └───────────────────────────────────────────────┘

Modelo de seguridad de defensa en profundidad de 5 capas

El sistema impone límites de seguridad estrictos entre el LLM y el motor de datos en 5 capas independientes:

Capa	Componente	Mecanismo de seguridad	Vector de amenaza mitigado
Capa 1: Puerta de AST previa a la ejecución	`agent/ast_validator.py`	Analizador léxico y sintáctico descendente recursivo en Python puro que verifica DQL de una sola sentencia (`SELECT`, `WITH ... SELECT`).	Inyección de consultas apiladas (`;`), DDL (`DROP`, `ALTER`, `CREATE`), DML (`INSERT`, `UPDATE`, `DELETE`), reconocimiento de PRAGMA, explotación de comentarios.
Capa 2: Puerta de coste previa a la ejecución	`agent/explain_analyzer.py`	Evalúa `EXPLAIN QUERY PLAN` de SQLite calculando puntuaciones de coste compuestas ($0-100$).	Productos cartesianos (combinaciones $O(N \times M)$), escaneos sin límite, agotamiento de memoria por B-trees temporales.
Capa 3: Modo de solo lectura del sistema operativo y del motor	`agent/db_engine.py`	Conexión SQLite establecida con la URI `file:<path>?mode=ro`.	Intentos no autorizados de escritura en disco, manipulación del esquema.
Capa 4: Autorizador en tiempo de ejecución	`agent/db_engine.py`	`sqlite3.set_authorizer` restringe las operaciones a `SQLITE_SELECT`, `SQLITE_READ`, `SQLITE_FUNCTION`, `SQLITE_RECURSIVE` y PRAGMAs de esquema seguros.	Evasiones intentan `ATTACH DATABASE`, `load_extension`, `PRAGMA writable_schema`, mutación de tablas.
Capa 5: Salvaguardas de recursos y memoria	`agent/db_engine.py`	Manejador de progreso de opcodes (`conn.set_progress_handler`) que supervisa el tiempo de ejecución de la consulta + truncado de filas con `fetchmany(max_rows + 1)`.	CTEs recursivos desbocados, denegación de servicio por CPU, fallos de memoria en resultados sin límite.

Validador de seguridad SQL AST (`agent/ast_validator.py`)

La puerta de seguridad AST implementa un motor de doble modo:

Analizador léxico y sintáctico descendente recursivo en Python puro y sin dependencias: Construido con bibliotecas estándar de Python e incluye seguimiento completo de coordenadas (línea/columna).
Motor sqlglot opcional: Analizador con conocimiento del uso de dialecto que se activa automáticamente si sqlglot está instalado.

Gramática SQL analítica compatible

DQL de una sola sentencia: SELECT y WITH [RECURSIVE] ... SELECT.
Expresiones de tabla común (CTEs): CTEs únicas y múltiples encadenadas. El analizador recorre recursivamente las definiciones de las CTEs garantizando que no haya DML incrustado.
Funciones de ventana: OVER (PARTITION BY ... ORDER BY ... [ROWS/RANGE ...]), ROW_NUMBER(), RANK(), SUM() OVER ().
Combinaciones (joins) entre múltiples tablas: INNER JOIN, LEFT OUTER JOIN, CROSS JOIN, NATURAL JOIN con ON y USING (...).
Subconsultas: Subconsultas en cláusulas FROM, subconsultas escalares en SELECT, IN (SELECT ...), EXISTS (SELECT ...).
Operaciones de conjunto compuestas: UNION [ALL], INTERSECT, EXCEPT.
Expresiones escalares: CASE WHEN ... THEN ... ELSE ... END, CAST(... AS ...), concatenación de cadenas (||), aritmética.

Patrones prohibidos (100% de bloqueo)

DDL: DROP, CREATE, ALTER, TRUNCATE.
DML: INSERT, UPDATE, DELETE, REPLACE, UPSERT, MERGE.
Comandos administrativos: PRAGMA, ATTACH, DETACH, VACUUM, REINDEX, ANALYZE, BEGIN, COMMIT.
Funciones peligrosas: load_extension, readfile, writefile, edit, fts3_tokenizer, eval, randomblob.
Tablas del sistema: sqlite_master, sqlite_schema, sqlite_temp_master, sqlite_temp_schema, sqlite_sequence, sqlite_stat*.
Vectores de inyección: Varias sentencias separadas por punto y coma (;), comentarios de bloque sin terminar (/* ...), literales de cadena sin terminar.

Analizador del plan de consulta EXPLAIN (`agent/explain_analyzer.py`)

Analiza el árbol de EXPLAIN QUERY PLAN de SQLite en el formato de 4 columnas de SQLite 3.24+ (id, parent, notused, detail) y en formatos heredados.

Fórmula de puntuación y penalizaciones

$$\text{CostScore} = \min\left(100, ; \sum \text{Penalties}\right)$$

Detalle de operación	Clasificación	Severidad	Penalización
`SCAN TABLE <table>`	Escaneo completo de tabla sin índice	Alta	+25,0 cada uno
`SEARCH TABLE <table> USING AUTOMATIC INDEX`	Construcción de índice efímero	Alta	+20,0
`USE TEMP B-TREE FOR ORDER BY`	Ordenación sin índice	Media	+15,0
`USE TEMP B-TREE FOR GROUP BY/DISTINCT`	Árbol B temporal de lagregación	Media	+10,0
`MATERIALIZE <id>`	Subconsulta materializada	Media	+10.0 cada
Escaneo sin índice de varias tablas	Combinación por producto cartesiano	Crítica	+30,0

Categorías de puntuación

$0.0 - 25.0$ (OPTIMAL): Búsquedas puntuales/por rango totalmente indexadas. Ejecución instantánea.
$26.0 - 50.0$ (ACCEPTABLE): Pequeña ordenación temporal o escaneo de una única tabla pequeña.
$51.0 - 74.0$ (WARNING): Plan subóptimo; múltiples escaneos.
$75.0 - 100.0$ (CRITICAL): Producto cartesiano o combinación pesada sin índice. Bloqueado por la puerta de ejecución de MCP.

Esquema del almacén de datos financieros (`data/schema.sql`)

El almacén de datos modela un dominio de financiación de activos de vehículos con 6 tablas relacionales:

┌──────────────┐       1:N       ┌──────────────┐       1:N       ┌──────────────┐
│   branches   ├────────────────►│  customers   ├────────────────►│credit_ratings│
└──────┬───────┘                 └──────┬───────┘                 └──────────────┘
       │ 1:N                            │ 1:N
       │         ┌──────────────┐       │
       └────────►│    loans     │◄──────┘
                 └──────┬───────┘
                        │ 1:N
                 ┌──────▼───────┐
                 │  repayments  │
                 └──────────────┘

┌──────────────┐
│  audit_log   │  (Immutable lifecycle state transition log)
└──────────────┘

branches: 12 centros regionales y sucursales minoristas con jerarquía recursiva padre-hijo (parent_branch_id).
customers: 300 perfiles de prestatarios con distribuciones de ingresos lognormales, ratios deude deuda/ingresos y hashes SHA-256 de PII.
credit_ratings: Más de 600 capturas longitudinales de puntuaciones de buró crediticio en 5 tramos de riesgo (PRIME_PLUS a DEEP_SUBPRIME).
loans: 500 contratos de financiación de vehículos y pymes con tipos de interés ajustados al riesgo y cuotas mensuales de amortización.
repayments: Más de 17,000 asientos contables con desglose de principal/intereses/comisiones y seguimiento de morosidad.
audit_log: Registros inmutables de auditoría que registran las transiciones de estado de los préstamos a DELINQUENT_90, DEFAULTED y WRITE_OFF.

Herramientas MCP e interfaz de protocolo JSON-RPC 2.0

El servidor (agent/server.py) expone 4 herramientas principales:

1. `query_database` (alias: `query_financial_lakehouse`)

Ejecuta consultas SQL seguras de solo lectura con validación automática del AST antes de la ejecución, timeout de progreso de opcodes y límite de filas.

Entrada: query (str, obligatoria), max_rows (int, valor por defecto: 100), timeout_seconds (float, valor por defecto: 5.0).
Salida: Carga útil JSON con columns, rows, row_count, is_truncated, execution_time_ms.

2. `explain_query`

Inspecciona los nodos del plan de ejecución, calcula la puntuación de coste ($0-100$), detecta escaneos y proporciona recomendaciones de indexación sin ejecutar mutaciones.

Entrada: query (str, obligatoria).
Salida: cost_score, complexity_rating, scanned_tables, indexed_tables, warnings, recommendations.

3. `get_database_schema`

Refleja los metadatos del catálogo de base de datos: tipos de columna, claves primarias, claves externas e índices.

Entrada: table_name (str, opcional).
Salida: Definiciones de esquema completas o filtradas por tabla.

4. `validate_sql_safety`

Realiza un análisis de seguridad estático del AST sin acceso a la base de datos.

Entrada: query (str, obligatoria).
Salida: is_safe (bool), statement_type, referenced_tables, detected_risks.

Agente autónomo y bucle de autocuración (`agent/with_init.py`)

El AutonomousDataAgent implementa un bucle iterativo de llamada a herramientas con remediación de errores en bucle cerrado:

                  ┌─────────────────────────────────────┐
                  │ User: "Top 5 default risk branches" │
                  └──────────────────┬──────────────────┘
                                     │
                                     ▼
                  ┌─────────────────────────────────────┐
                  │ Turn 1: Introspect Database Schema  │
                  └──────────────────┬──────────────────┘
                                     │
                                     ▼
                  ┌─────────────────────────────────────┐
                  │ Turn 2: Synthesize & Explain Plan   │
                  └──────────┬──────────────────────┬───┘
                             │                      │
             Plan Warning /  ▼                      ▼ Pass
             Cartesian Join  ┌──────────────────┐   ┌──────────────────┐
                             │ 🔄 Repair Query  │   │ Turn 3: Execute  │
                             │ (Add JOIN ... ON)│   │  query_database  │
                             └────────┬─────────┘   └────────┬─────────┘
                                      │                      │
                                      ▼                      ▼
                             ┌──────────────────┐   ┌──────────────────┐
                             │ Turn 4: Re-check │   │ Synthesize Final │
                             │   & Run Query    │   │ Executive Report │
                             └──────────────────┘   └──────────────────┘

Escenarios de autocorrección gestionados

Error de sintaxis / esquema de SQLite (p. ej. nombre de columna mal escrito): inyecta de template SYNTAX_ERROR_TEMPLATE con el catálogo de esquema; el agente corrige los nombres de columna..
Rechazo por seguridad del AST (p. ej. consulta no DQL): inyecta el template de plantilla AST_VIOLATION_TEMPLATE; el agente reformula una consulta SELECT simple compatible.
Consulta de coste elevado / combinación cartesiana: inyecta el PLAN_WARNING_TEMPLATE; el agente añade in conditions de combinación (join) con índices.
Ejecución determinista sin conexión: MockClaudeClient permite probar 100% sin conexión y sin necesidad de una API key de Anthropic.

Guía de inicio rápido y verificación

1. Instalación y configuración del entorno

# Clone and navigate to repository
cd MCP_Autonomous_Agent

# Install dependencies
pip install -r requirements.txt

2. Generar datos semilla del almacén de datos

Rellena data/warehouse.db con datos sintéticos financieros deterministas (semilla fija 42):

python data/seed_warehouse.py

Output:

[SeedWarehouse] branches        :     12 rows
[SeedWarehouse] customers       :    300 rows
[SeedWarehouse] credit_ratings  :    627 rows
[SeedWarehouse] loans           :    500 rows
[SeedWarehouse] repayments      :  17120 rows
[SeedWarehouse] audit_log       :     44 rows
[SeedWarehouse] Database seeding successfully completed.

3. Ejecutar la suite de pruebas completa

Ejecuta todos los 66 tests unitarios y de integración en valoración AST, análisis EXPLAIN, seguridad de hilos del motor de DB, herramientas MCP y los bucles de autocuración del agente:

python -m unittest discover -s tests -v

4. Ejecutar la demo del agente autónomo

Ejecuta una sesión de consulta analítica de varios turnos contra el almacén de datos financieros.

from agent.client_runner import AutonomousDataAgent

agent = AutonomousDataAgent()
response = agent.run("Identify the top default risk branches with delinquency counts and total exposure")

print(f"Success: {response.success}")
print(f"Turns Taken: {response.turns_taken}")
print(f"SQL Executed: {response.sql_executed}")
print(f"\n{response.final_answer}")

5. Iniciar servidor MCP en Stdio

Para conectar con la aplicación Anthropic Claude Desktop o con MCP Inspector:

python agent/server.py

Configuración en claude_desktop_config.json de Claude Desktop:

{
  "mcpServers": {
    "financial-data-agent": {
      "command": "python",
      "args": ["-m", "agent.server"],
      "cwd": "/path/to/MCP_Autonomous_Agent"
    }
  }
}

Estructura del proyecto

MCP_Autonomous_Agent/
├── data/
│   ├── __init__.py
│   ├── schema.sql              # 6-table relational financial warehouse DDL
│   ├── seed_warehouse.py       # Deterministic synthetic data generator (seed 42)
│   └── warehouse.db            # Generated SQLite database file
├── agent/
│   ├── __init__.py
│   ├── ast_validator.py        # Pure-Python SQL Lexer & Recursive Descent AST Parser
│   ├── explain_analyzer.py     # SQLite EXPLAIN QUERY PLAN analyzer & cost scorer
│   ├── db_engine.py            # Thread-safe read-only connection pool & opcode timeout
│   ├── prompts.py              # System prompts, tool schemas & remediation templates
│   ├── client_runner.py        # Autonomous agent loop with closed-loop self-correction
│   └── server.py               # MCP JSON-RPC 2.0 stdio server implementation
├── tests/
│   ├── __init__.py
│   ├── test_ast_validator.py   # Unit tests for AST security and analytical DQL (29 tests)
│   ├── test_explain_analyzer.py# Unit tests for plan parsing, scans, cartesian (7 tests)
│   ├── test_db_engine.py       # Unit tests for read-only pool, timeouts, threads (8 tests)
│   ├── test_mcp_tools.py       # Unit tests for MCP protocol, tool calls, errors (15 tests)
│   └── test_client_runner.py   # Unit tests for agent loop and self-healing (5 tests)
├── requirements.txt            # Dependency specification (mcp, anthropic, sqlglot, pytest)
└── README.md                   # Complete architectural & technical documentation

Licencia

MIT License. Creado para el análisis analítico financiero empresarial y la demostración de un portafolio de agentes de IA.

This server cannot be installed

license - not tested

Not graded

quality - not tested

maintenance

How are these scores calculated?

Maintenance

–Maintainers

–Response time

–Release cycle

–Releases (12mo)

Commit activity

Resources

GitHub Repository

Need Help?

Related Servers

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Related MCP Connectors

PlainQuery | MCP DB Agent
Query PostgreSQL databases in plain English — LLM-generated, safety-validated SQL.
Prism — Crossdeck
Ask your app anything — revenue, errors, read-cost, growth — and get rendered charts back.
BankBridge
Read-only bank access for your AI agent. Connects Claude, ChatGPT, Cursor, Gemini, Codex.

View all MCP Connectors

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/fortuneMog/MCP_Autonomous_Agent'

If you have feedback or need assistance with the MCP directory API, please join our Discord server