MCP Server Tutorial: Cómo conectar ChatGPT a tus datos reales (sin volverte loco)

Mira, colega, llevo semanas viendo tutoriales de MCP Server que parecen manuales de la NASA. Todo el mundo habla de "protocolo de contexto de modelo" y "arquitectura cliente-servidor" como si fuera un máster en informática. Pero tú y yo sabemos que lo que realmente quieres es que ChatGPT, Claude o cualquier IA pueda acceder a tus archivos, bases de datos o APIs sin tener que pegarle 40 prompts cada vez.

Voy al grano: MCP (Model Context Protocol) es el pegamento que falta entre la IA y tus datos. Piensa en ello como si le dieras a ChatGPT un enchufe USB directo a tu servidor. En lugar de explicarle qué hay en tu base de datos, él mismo va, consulta y te responde con datos reales. No más alucinaciones, no más "lo siento, no tengo acceso a esa información".

¿Qué necesitas para montar tu primer MCP Server?

Un VPS o servidor con Node.js 18+, Python 3.9+ o Go. Yo uso Node porque es lo que mejor se lleva con las herramientas modernas. También necesitas una API key de OpenAI o Anthropic, pero si estás leyendo esto, seguro que ya tienes una.

3 Prompts funcionales para tu MCP Server

Aquí van los prompts que realmente usas, colega. Cópialos, pégalos y ajusta lo que necesites:

1. Prompt para configurar un MCP Server básico desde cero

Configuración inicial de un MCP Server con Node.js

mkdir mcp-server-demo

cd mcp-server-demo

npm init -y

npm install @modelcontextprotocol/sdk express cors dotenv

Crea el archivo principal

cat > server.js << 'EOF'

const { MCPServer } = require('@modelcontextprotocol/sdk');

const express = require('express');

const server = new MCPServer({

name: 'mi-servidor-datos',

version: '1.0.0',

tools: [

{

name: 'consultar_bd',

description: 'Consulta una base de datos SQLite local',

parameters: {

type: 'object',

properties: {

query: { type: 'string', description: 'Consulta SQL' }

}

},

handler: async ({ query }) => {

// Aquí iría tu lógica de conexión a BD

return { resultado: Ejecutando: ${query} };

}

}

]

});

server.listen(3000);

console.log('MCP Server corriendo en puerto 3000');

EOF

2. Prompt para conectar ChatGPT a tu MCP Server

Prompt para configurar el cliente MCP en tu app de ChatGPT

import requests

MCP_SERVER_URL = "http://localhost:3000/mcp"

def conectar_chatgpt_a_mcp():

# Registra las herramientas disponibles

herramientas = requests.get(f"{MCP_SERVER_URL}/tools").json()

# Cuando ChatGPT necesite datos, llama a esta función

def ejecutar_herramienta(nombre, parametros):

respuesta = requests.post(

f"{MCP_SERVER_URL}/execute",

json={"tool": nombre, "parameters": parametros}

)

return respuesta.json()

return ejecutar_herramienta

Uso: conecta y deja que ChatGPT llame a tus herramientas

conector = conectar_chatgpt_a_mcp()

resultado = conector("consultar_bd", {"query": "SELECT * FROM usuarios"})

print(resultado)

3. Prompt para añadir autenticación y seguridad a tu MCP Server

// MCP Server con autenticación JWT

const jwt = require('jsonwebtoken');

// Middleware de autenticación

const authMiddleware = (req, res, next) => {

const token = req.headers['authorization'];

if (!token) return res.status(401).json({ error: 'Token requerido' });

try {

const decoded = jwt.verify(token, process.env.JWT_SECRET);

req.usuario = decoded;

next();

} catch (error) {

res.status(403).json({ error: 'Token inválido' });

}

};

// Aplica el middleware a todas las rutas del MCP

server.use(authMiddleware);

4. Prompt para depurar problemas comunes en MCP Server

Debug de conexión MCP

1. Verifica que el servidor esté vivo

curl -X GET http://localhost:3000/health

2. Lista herramientas disponibles

curl -X GET http://localhost:3000/mcp/tools

3. Prueba una ejecución simple

curl -X POST http://localhost:3000/mcp/execute \

-H "Content-Type: application/json" \

-d '{"tool": "ping", "parameters": {}}'

4. Logs en tiempo real

tail -f /var/log/mcp-server.log

5. Prompt para integrar MCP Server con tu base de datos PostgreSQL

Conexión MCP Server a PostgreSQL

import asyncpg

from mcp_sdk import MCPServer

class MCPPostgreSQLServer(MCPServer):

def __init__(self):

super().__init__(name="postgres-mcp", version="1.0.0")

self.db_pool = None

async def conectar_bd(self):

self.db_pool = await asyncpg.create_pool(

user='usuario',

password='contraseña',

database='midb',

host='localhost'

)

@MCPServer.tool()

async def consultar_ventas(self, fecha_inicio: str, fecha_fin: str):

async with self.db_pool.acquire() as conn:

resultado = await conn.fetch("""

SELECT producto, SUM(cantidad) as total

FROM ventas

WHERE fecha BETWEEN $1 AND $2

GROUP BY producto

""", fecha_inicio, fecha_fin)

return [dict(row) for row in resultado]

Inicialización

server = MCPPostgreSQLServer()

await server.conectar_bd()

server.run(host='0.0.0.0', port=3001)

¿Y ahora qué hago con esto?

Mira, tío, el MCP Server no es magia, pero casi. Lo que acabas de montar te permite que cualquier IA hable directamente con tus datos. ¿Tienes un CRM? Conéctalo. ¿Una base de productos? Ahí lo tienes. ¿Quieres que ChatGPT te genere informes de ventas en tiempo real? Ya sabes cómo.

El truco está en pensar qué herramientas quieres exponer. No des acceso total a tu base de datos (aunque puedas), mejor crea funciones específicas: "dame_ventas_del_dia", "busca_producto_por_sku", "genera_resumen_de_cliente". Así controlas qué ve y qué hace la IA.

Y tú, ¿qué prompt usas para que tu IA hable con tus datos reales? Cuéntamelo en los comentarios, que esto solo acaba de empezar.