Trino MCP サーバー

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

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

# 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

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

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

# 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"])

# Generate the bullshit data
python tools/create_bullshit_data.py

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

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

🏆 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!

# Test the Docker container API 
python test_llm_api.py

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

# 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

# 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

# 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

# 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

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

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

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

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

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

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

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

%%{init: {'theme': 'forest'}}%%
graph LR
 title[Companies with Most Bullshit Jobs]
 style title fill:#333,stroke:#333,stroke-width:1px,color:white,font-weight:bold,font-size:18px

 Companies --> UnknownCo[Unknown Co]
 Companies --> BitEdge[BitEdge]
 Companies --> CyberWare[CyberWare]
 Companies --> BitLink[BitLink]
 Companies --> AlgoMatrix[AlgoMatrix]
 Companies --> CryptoHub[CryptoHub]
 Companies --> BitGrid[BitGrid]
 Companies --> MLStream[MLStream]
 Companies --> CloudCube[CloudCube]
 Companies --> UltraEdge[UltraEdge]
 
 UnknownCo --- Count2[2 employees]
 BitEdge --- Count1a[1 employee]
 CyberWare --- Count1b[1 employee]
 BitLink --- Count1c[1 employee]
 AlgoMatrix --- Count1d[1 employee]
 CryptoHub --- Count1e[1 employee]
 BitGrid --- Count1f[1 employee]
 MLStream --- Count1g[1 employee]
 CloudCube --- Count1h[1 employee]
 UltraEdge --- Count1i[1 employee]
 
 classDef company fill:#ff5733,stroke:#333,stroke-width:1px,color:white,font-weight:bold;
 classDef count fill:#006100,stroke:#333,stroke-width:1px,color:white,font-weight:bold;
 
 class UnknownCo,BitEdge,CyberWare,BitLink,AlgoMatrix,CryptoHub,BitGrid,MLStream,CloudCube,UltraEdge company;
 class Count2,Count1a,Count1b,Count1c,Count1d,Count1e,Count1f,Count1g,Count1h,Count1i count;

%%{init: {'theme': 'default'}}%%
pie showData
 title Companies with Bullshit Jobs
 "Unknown Co (BS: 9.0)" : 2
 "BitEdge (BS: 10.0)" : 1
 "CyberWare (BS: 10.0)" : 1
 "BitLink (BS: 10.0)" : 1
 "AlgoMatrix (BS: 10.0)" : 1
 "CryptoHub (BS: 10.0)" : 1
 "BitGrid (BS: 10.0)" : 1
 "MLStream (BS: 10.0)" : 1
 "CloudCube (BS: 10.0)" : 1
 "UltraEdge (BS: 10.0)" : 1

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']}")

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

Looking for Admin?