Servidor Trino MCP

Servidor de protocolo de contexto de modelo para Trino, que proporciona modelos de IA con acceso estructurado al motor de consulta SQL distribuido de Trino.

⚠️ VERSIÓN BETA (v0.1.2) ⚠️
Este proyecto se está estabilizando y sus funciones principales funcionan y están probadas. ¡Siéntete libre de bifurcar y contribuir!

Características

✅ ¡Se solucionó el problema de inicialización de la API del contenedor Docker! (inicialización confiable del servidor)
✅ Expone recursos de Trino a través del protocolo MCP
✅ Permite que las herramientas de IA consulten y analicen datos en Trino
✅ Proporciona opciones de transporte (el transporte STDIO funciona de manera confiable; el transporte SSE tiene problemas)
✅ Se corrigió el manejo del catálogo para la correcta ejecución de consultas Trino
✅ Opciones de servidor API de Python independiente y API de contenedor Docker

Inicio rápido

# Start the server with docker-compose
docker-compose up -d

# Verify the API is working
curl -X POST "http://localhost:9097/api/query" \
     -H "Content-Type: application/json" \
     -d '{"query": "SELECT 1 AS test"}'

¿Necesita una versión sin contenedor? Ejecute la API independiente:

# Run the standalone API server on port 8008
python llm_trino_api.py

Integración de LLM

¿Quieres que un LLM tenga acceso directo para consultar tu instancia de Trino? ¡Hemos creado herramientas sencillas para ello!

Interfaz LLM de línea de comandos

La forma más sencilla de permitir que un LLM consulte a Trino es a través de nuestra herramienta de línea de comandos:

# Simple direct query (perfect for LLMs)
python llm_query_trino.py "SELECT * FROM memory.bullshit.real_bullshit_data LIMIT 5"

# Specify a different catalog or schema
python llm_query_trino.py "SELECT * FROM information_schema.tables" memory information_schema

API REST para LLM

Ofrecemos dos opciones de API para la integración con aplicaciones LLM:

1. API de contenedor Docker (Puerto 9097)

El contenedor Docker expone una API REST en el puerto 9097:

# Execute a query against the Docker container API
curl -X POST "http://localhost:9097/api/query" \
     -H "Content-Type: application/json" \
     -d '{"query": "SELECT 1 AS test"}'

2. API independiente de Python (puerto 8008)

Para implementaciones más flexibles, ejecute el servidor API independiente:

# Start the API server on port 8008
python llm_trino_api.py

Esto crea puntos finales en:

GET http://localhost:8008/ - Información de uso de la API
POST http://localhost:8008/query - Ejecutar consultas SQL

Luego puede hacer que su LLM realice solicitudes HTTP a este punto final:

# Example code an LLM might generate
import requests

def query_trino(sql_query):
    response = requests.post(
        "http://localhost:8008/query",
        json={"query": sql_query}
    )
    return response.json()

# LLM-generated query
results = query_trino("SELECT job_title, AVG(salary) FROM memory.bullshit.real_bullshit_data GROUP BY job_title ORDER BY AVG(salary) DESC LIMIT 5")
print(results["formatted_results"])

Este enfoque permite que los LLM se concentren en generar SQL, mientras nuestras herramientas manejan toda la complejidad del protocolo MCP.

Scripts de demostración y validación 🚀

Hemos creado algunos scripts de demostración increíbles que muestran cómo los modelos de IA pueden usar el protocolo MCP para ejecutar consultas complejas en Trino:

1. Generación y carga de datos basura

El script tools/create_bullshit_data.py genera un conjunto de datos de 10 000 empleados con cargos ridículos, salarios inflados y una calificación de "factor de estupidez" (del 1 al 10):

# Generate the bullshit data
python tools/create_bullshit_data.py

# Load the bullshit data into Trino's memory catalog
python load_bullshit_data.py

2. Ejecución de consultas complejas a través de MCP

El script test_bullshit_query.py demuestra la interacción MCP de extremo a extremo:

Se conecta al servidor MCP mediante el transporte STDIO
Inicializa el protocolo siguiendo la especificación MCP
Ejecuta una consulta SQL compleja con WHERE, GROUP BY, HAVING, ORDER BY
Procesa y formatea los resultados

# Run a complex query against the bullshit data through MCP
python test_bullshit_query.py

Ejemplo de salida que muestra los mejores trabajos de BS con salarios altos:

🏆 TOP 10 BULLSHIT JOBS (high salary, high BS factor):
----------------------------------------------------------------------------------------------------
JOB_TITLE             | COUNT                | AVG_SALARY           | MAX_SALARY           | AVG_BS_FACTOR        
----------------------------------------------------------------------------------------------------
Advanced Innovation Jedi | 2                    |            241178.50 |            243458.00 |                 7.50
VP of Digital Officer | 1                    |            235384.00 |            235384.00 |                 7.00
Innovation Technical Architect | 1                    |            235210.00 |            235210.00 |                 9.00
...and more!

3. Pruebas de API

El script test_llm_api.py valida la funcionalidad de la API:

# Test the Docker container API 
python test_llm_api.py

Esto realiza una verificación exhaustiva de:

Descubrimiento de puntos finales de API
Disponibilidad de la documentación
Ejecución de consulta válida
Manejo de errores para consultas no válidas

Uso

# Start the server with docker-compose
docker-compose up -d

El servidor estará disponible en:

Conexión del cliente

✅ IMPORTANTE : Los scripts del cliente se ejecutan en tu equipo local (FUERA de Docker) y se conectan a los contenedores Docker. Los scripts gestionan esto automáticamente mediante comandos docker exec. ¡No necesitas estar dentro del contenedor para usar MCP!

Ejecutar pruebas desde su máquina local:

# Generate and load data into Trino
python tools/create_bullshit_data.py  # Generates data locally
python load_bullshit_data.py          # Loads data to Trino in Docker

# Run MCP query through Docker
python test_bullshit_query.py         # Queries using MCP in Docker

Opciones de transporte

Este servidor admite dos métodos de transporte, pero actualmente solo STDIO es confiable:

Transporte STDIO (recomendado y funcional)

El transporte STDIO funciona de manera confiable y actualmente es el único método recomendado para pruebas y desarrollo:

# Run with STDIO transport inside the container
docker exec -i trino_mcp_trino-mcp_1 python -m trino_mcp.server --transport stdio --debug --trino-host trino --trino-port 8080 --trino-user trino --trino-catalog memory

Transporte SSE (NO RECOMENDADO - Presenta problemas críticos)

SSE es el transporte predeterminado en MCP, pero presenta graves problemas con la versión actual de MCP 1.3.0, que provocan fallos del servidor al desconectarse el cliente. No se recomienda su uso hasta que se resuelvan estos problemas :

# NOT RECOMMENDED: Run with SSE transport (crashes on disconnection)
docker exec trino_mcp_trino-mcp_1 python -m trino_mcp.server --transport sse --host 0.0.0.0 --port 8000 --debug

Problemas conocidos y soluciones

Corregido: Inicialización de la API del contenedor Docker

SOLUCIONADO : Se solucionó un problema por el cual la API del contenedor Docker devolvía respuestas 503 "Servicio no disponible". El problema se debía a que la función app_lifespan no inicializaba correctamente app_context_global ni la conexión del cliente Trino. La solución garantiza que:

El cliente Trino se conecta explícitamente durante el inicio
La variable global AppContext se inicializa correctamente
Los controles de salud ahora funcionan correctamente

Si encuentra errores 503, verifique que su contenedor se haya reconstruido con el código más reciente:

# Rebuild and restart the container with the fix
docker-compose stop trino-mcp
docker-compose rm -f trino-mcp
docker-compose up -d trino-mcp

Fallos del transporte SSE de MCP 1.3.0

Hay un problema crítico con el transporte SSE de MCP 1.3.0 que provoca fallos del servidor cuando los clientes se desconectan. Hasta que se integre una versión más reciente de MCP, utilice exclusivamente el transporte STDIO. El error se manifiesta como:

RuntimeError: generator didn't stop after athrow()
anyio.BrokenResourceError

Manejo del catálogo Trino

Se solucionó un problema con la gestión del catálogo en el cliente Trino. La implementación original intentaba usar sentencias USE catalog , lo cual no funcionaba correctamente. La solución establece el catálogo directamente en los parámetros de conexión.

Estructura del proyecto

Este proyecto está organizado de la siguiente manera:

src/ - Código fuente principal del servidor Trino MCP
examples/ - Ejemplos sencillos que muestran cómo utilizar el servidor
scripts/ - Scripts útiles de diagnóstico y prueba
tools/ - Scripts de utilidad para la creación y configuración de datos
tests/ - Pruebas automatizadas

Archivos clave:

llm_trino_api.py : servidor API independiente para la integración de LLM
test_llm_api.py - Script de prueba para el servidor API
test_mcp_stdio.py - Script de prueba principal que utiliza el transporte STDIO (recomendado)
test_bullshit_query.py - Ejemplo de consulta compleja con datos falsos
load_bullshit_data.py - Script para cargar datos generados en Trino
tools/create_bullshit_data.py - Script para generar datos de prueba divertidos
run_tests.sh - Script para ejecutar pruebas automatizadas
examples/simple_mcp_query.py - Ejemplo simple para consultar datos usando MCP

Desarrollo

IMPORTANTE : Todos los scripts se pueden ejecutar desde su máquina local: se comunicarán automáticamente con los contenedores Docker a través de comandos docker exec.

# Install development dependencies
pip install -e ".[dev]"

# Run automated tests 
./run_tests.sh

# Test MCP with STDIO transport (recommended)
python test_mcp_stdio.py

# Simple example query
python examples/simple_mcp_query.py "SELECT 'Hello World' AS message"

Pruebas

Para probar que las consultas Trino funcionan correctamente, utilice el script de prueba de transporte STDIO:

# Recommended test method (STDIO transport)
python test_mcp_stdio.py

Para realizar pruebas más complejas con datos falsos:

# Load and query the bullshit data (shows the full power of Trino MCP!)
python load_bullshit_data.py
python test_bullshit_query.py

Para probar el punto final de la API de LLM:

# Test the Docker container API
python test_llm_api.py 

# Test the standalone API (make sure it's running first)
python llm_trino_api.py
curl -X POST "http://localhost:8008/query" \
     -H "Content-Type: application/json" \
     -d '{"query": "SELECT 1 AS test"}'

Cómo los LLM pueden usar esto

Los LLM pueden utilizar el servidor Trino MCP para:

Obtener información del esquema de la base de datos :
# Example prompt to LLM: "What schemas are available in the memory catalog?" # LLM can generate code to query: query = "SHOW SCHEMAS FROM memory"
Ejecutar consultas analíticas complejas :
# Example prompt: "Find the top 5 job titles with highest average salaries" # LLM can generate complex SQL: query = """ SELECT job_title, AVG(salary) as avg_salary FROM memory.bullshit.real_bullshit_data GROUP BY job_title ORDER BY avg_salary DESC LIMIT 5 """
Realizar análisis de datos y presentar resultados :
# LLM can parse the response, extract insights and present to user: "The highest paying job title is 'Advanced Innovation Jedi' with an average salary of $241,178.50"

Ejemplo de análisis real de LLM: trabajos basura por empresa

He aquí un ejemplo real de lo que un LLM podría producir cuando se le pide "Identificar las empresas con la mayor cantidad de empleados en trabajos de mierda y crear un gráfico de sirena":

Paso 1: LLM genera y ejecuta la consulta

SELECT 
  company, 
  COUNT(*) as employee_count, 
  AVG(bullshit_factor) as avg_bs_factor 
FROM 
  memory.bullshit.real_bullshit_data 
WHERE 
  bullshit_factor > 7 
GROUP BY 
  company 
ORDER BY 
  employee_count DESC, 
  avg_bs_factor DESC 
LIMIT 10

Paso 2: LLM obtiene y analiza los resultados

COMPANY | EMPLOYEE_COUNT | AVG_BS_FACTOR
----------------------------------------
Unknown Co | 2 | 9.0
BitEdge | 1 | 10.0
CyberWare | 1 | 10.0
BitLink | 1 | 10.0
AlgoMatrix | 1 | 10.0
CryptoHub | 1 | 10.0
BitGrid | 1 | 10.0
MLStream | 1 | 10.0
CloudCube | 1 | 10.0
UltraEdge | 1 | 10.0

Paso 3: LLM genera una visualización del gráfico de sirena

Gráfico de barras alternativo:

Paso 4: LLM proporciona información clave

El LLM puede analizar los datos y proporcionar información:

"Unknown Co" tiene la mayor cantidad de empleados en roles de mierda (2), mientras que todos los demás tienen solo uno
La mayoría de las empresas han conseguido una puntuación perfecta de 10,0 en el factor de estupidez.
Las empresas centradas en la tecnología (BitEdge, CyberWare, etc.) parecen crear roles particularmente insignificantes
Los roles de mierda aparecen concentrados en niveles ejecutivos o de puestos especializados

Este ejemplo demuestra cómo un LLM puede:

Generar consultas SQL apropiadas basadas en preguntas en lenguaje natural
Procesar e interpretar los resultados de Trino
Crear representaciones visuales de los datos
Proporcionar información y análisis significativos

Accediendo a la API

El servidor Trino MCP ahora incluye dos opciones de API para acceder a los datos:

1. API de contenedor Docker (Puerto 9097)

import requests
import json

# API endpoint (default port 9097 in Docker setup)
api_url = "http://localhost:9097/api/query"

# Define your SQL query
query_data = {
    "query": "SELECT * FROM memory.bullshit.real_bullshit_data LIMIT 5",
    "catalog": "memory",
    "schema": "bullshit"
}

# Send the request
response = requests.post(api_url, json=query_data)
results = response.json()

# Process the results
if results["success"]:
    print(f"Query returned {results['results']['row_count']} rows")
    for row in results['results']['rows']:
        print(row)
else:
    print(f"Query failed: {results['message']}")

2. API independiente de Python (puerto 8008)

# Same code as above, but with different port
api_url = "http://localhost:8008/query"

Ambas API ofrecen los siguientes puntos finales:

GET /api - Documentación de la API y ejemplos de uso
POST /api/query - Ejecutar consultas SQL contra Trino

Estas API eliminan la necesidad de scripts envolventes y permiten que los LLM consulten a Trino directamente mediante llamadas REST, lo que hace que sea mucho más sencilla la integración con servicios como Claude, GPT y otros sistemas de IA.

Solución de problemas

La API devuelve el error 503: Servicio no disponible

Si la API del contenedor Docker devuelve errores 503:

Asegúrese de haber reconstruido el contenedor con el código más reciente:
docker-compose stop trino-mcp docker-compose rm -f trino-mcp docker-compose up -d trino-mcp
Verifique los registros del contenedor para detectar errores:
docker logs trino_mcp_trino-mcp_1
Verifique que Trino esté funcionando correctamente:
curl -s http://localhost:9095/v1/info | jq

Conflictos de puertos con API independientes

La API independiente usa el puerto 8008 por defecto para evitar conflictos. Si ve el error "Dirección ya en uso":

Edite llm_trino_api.py y cambie el número de puerto en la última línea:
uvicorn.run(app, host="127.0.0.1", port=8008)
Ejecutar con un puerto personalizado a través de la línea de comando:
python -c "import llm_trino_api; import uvicorn; uvicorn.run(llm_trino_api.app, host='127.0.0.1', port=8009)"

Trabajo futuro

Esta versión ahora está en versión beta con las siguientes mejoras planificadas:

[ ] Integrar con versiones más nuevas de MCP cuando estén disponibles para solucionar problemas de transporte de SSE
[ ] Agregar/Validar soporte para Hive, JDBC y otros conectores
[ ] Agregue una validación de consultas más completa en diferentes tipos y complejidades
[ ] Implementar soporte para más tipos de datos y funciones avanzadas de Trino
[ ] Mejorar los mecanismos de gestión y recuperación de errores
[ ] Agregar controles de permisos y autenticación de usuarios
[ ] Crear ejemplos y documentación más completos
[ ] Desarrollar interfaces de gestión y monitoreo administrativo
[ ] Agregar métricas de rendimiento y sugerencias de optimización de consultas
[ ] Implementar soporte para consultas de larga duración y transmisión de resultados

Desarrollado por Stink Labs, 2025

Integrations

Servidor Trino MCP

Características

Inicio rápido

Integración de LLM

Interfaz LLM de línea de comandos

API REST para LLM

1. API de contenedor Docker (Puerto 9097)

2. API independiente de Python (puerto 8008)

Scripts de demostración y validación 🚀

1. Generación y carga de datos basura

2. Ejecución de consultas complejas a través de MCP

3. Pruebas de API

Uso

Conexión del cliente

Opciones de transporte

Transporte STDIO (recomendado y funcional)

Transporte SSE (NO RECOMENDADO - Presenta problemas críticos)

Problemas conocidos y soluciones

Corregido: Inicialización de la API del contenedor Docker

Fallos del transporte SSE de MCP 1.3.0

Manejo del catálogo Trino

Estructura del proyecto

Desarrollo

Pruebas

Cómo los LLM pueden usar esto

Ejemplo de análisis real de LLM: trabajos basura por empresa

Paso 1: LLM genera y ejecuta la consulta

Paso 2: LLM obtiene y analiza los resultados

Paso 3: LLM genera una visualización del gráfico de sirena

Paso 4: LLM proporciona información clave

Accediendo a la API

1. API de contenedor Docker (Puerto 9097)

2. API independiente de Python (puerto 8008)

Solución de problemas

La API devuelve el error 503: Servicio no disponible

Conflictos de puertos con API independientes

Trabajo futuro

Tools

Related Resources

Appeared in Searches