¿Qué es un servidor MCP y por qué necesitas uno?

MCP (Model Context Protocol) es un protocolo abierto desarrollado por Anthropic que permite conectar modelos de lenguaje como Claude con fuentes de datos externas, herramientas y APIs. Un servidor MCP actúa como un puente entre el modelo y el mundo exterior, permitiendo que el asistente acceda a información en tiempo real, ejecute cálculos, consulte bases de datos o interactúe con servicios web. Si estás construyendo aplicaciones con asistentes de IA que necesitan datos actualizados o capacidades específicas, crear tu propio servidor MCP te da control total sobre qué información comparte tu modelo y cómo lo hace. En esta guía práctica construirás desde cero un servidor funcional usando Python, sin frameworks complejos, solo con las herramientas estándar del lenguaje.

Tip: Antes de empezar, asegúrate de tener Python 3.10+ instalado. Usa un entorno virtual para mantener tus dependencias organizadas: python -m venv mcp_server y actívalo con source mcp_server/bin/activate en Linux/Mac o mcp_server\Scripts\activate en Windows.

Estructura básica del servidor MCP

Un servidor MCP sigue un patrón simple: escucha peticiones entrantes, las procesa según las herramientas registradas y devuelve respuestas estructuradas en JSON. Para empezar, necesitas tres componentes esenciales: un manejador de conexiones (usaremos sockets TCP), un registrador de herramientas (donde defines qué puede hacer tu servidor) y un enrutador de solicitudes (que dirige cada petición a la herramienta correcta). La implementación más ligera usa el módulo socket de Python, aunque para producción podrías usar asyncio o frameworks como FastAPI. Aquí tienes la estructura mínima:

PROMPTimport socket

import json

import threading

Registro de herramientas

tools = {}

def register_tool(name, handler):

tools[name] = handler

def handle_request(data):

try:

request = json.loads(data)

tool_name = request.get("tool")

params = request.get("params", {})

if tool_name in tools:

result = toolstool_name

return json.dumps({"status": "success", "data": result})

else:

return json.dumps({"status": "error", "message": f"Tool '{tool_name}' not found"})

except Exception as e:

return json.dumps({"status": "error", "message": str(e)})

def start_server(host="127.0.0.1", port=5000):

server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

server.bind((host, port))

server.listen(5)

print(f"MCP Server listening on {host}:{port}")

while True:

client, addr = server.accept()

data = client.recv(4096).decode()

response = handle_request(data)

client.send(response.encode())

client.close()

if __name__ == "__main__":

start_server()

Este código crea un servidor TCP básico que acepta conexiones, recibe datos JSON, los procesa con las herramientas registradas y devuelve respuestas. La función register_tool permite añadir nuevas capacidades dinámicamente. Observa que el servidor maneja cada conexión de forma secuencial; para múltiples clientes simultáneos, puedes envolver la lógica del cliente en un hilo.

ComponenteFunciónEjemplo

SocketEscucha y acepta conexionesserver.listen(5)

RegistroAlmacena herramientas por nombretools["sumar"] = sumar_handler

EnrutadorDirige peticiones a handlershandle_request(data)

Implementando herramientas funcionales

Ahora añadiremos herramientas reales que tu servidor MCP pueda ejecutar. Cada herramienta es una función que recibe parámetros y devuelve datos. Por ejemplo, una calculadora simple, un consultor de clima simulado y un generador de IDs únicos. La clave está en que el handler recibe un diccionario con los parámetros y debe devolver datos serializables en JSON. Aquí tienes tres herramientas listas para usar:

PROMPTimport random

import time

import math

Herramienta 1: Calculadora

def calculator(params):

operation = params.get("operation")

a = params.get("a", 0)

b = params.get("b", 0)

if operation == "sum":

return {"result": a + b}

elif operation == "multiply":

return {"result": a * b}

elif operation == "power":

return {"result": a ** b}

else:

raise ValueError(f"Unknown operation: {operation}")

Herramienta 2: Simulador de clima

def get_weather(params):

city = params.get("city", "unknown")

# Simulación: genera datos aleatorios

temp = round(random.uniform(15, 35), 1)

humidity = random.randint(40, 90)

return {

"city": city,

"temperature": temp,

"humidity": humidity,

"timestamp": time.time()

}

Herramienta 3: Generador de UUIDs

def generate_id(params):

import uuid

count = params.get("count", 1)

ids = [str(uuid.uuid4()) for _ in range(count)]

return {"ids": ids, "generated": count}

Registramos las herramientas

register_tool("calculator", calculator)

register_tool("weather", get_weather)

register_tool("generate_id", generate_id)

Estas herramientas son intencionalmente simples para que entiendas el patrón: reciben parámetros, los procesan y devuelven un diccionario. En producción, podrías conectar get_weather a una API real como OpenWeatherMap, o calculator podría incluir operaciones más complejas. La magia del MCP está en que cualquier función Python puede convertirse en herramienta, desde consultas SQL hasta llamadas a APIs externas. Asegúrate de que cada handler maneje errores con try/except y devuelva siempre un diccionario, porque el servidor serializará la respuesta a JSON automáticamente.

Tip: Para probar tu servidor sin un cliente MCP completo, usa netcat o telnet. En otra terminal ejecuta: echo '{"tool":"calculator","params":{"operation":"sum","a":5,"b":3}}' | nc 127.0.0.1 5000. Recibirás: {"status":"success","data":{"result":8}}. Es la forma más rápida de depurar.

Conectando con un cliente MCP y buenas prácticas

Una vez que tu servidor está funcionando, necesitas un cliente que hable el mismo protocolo. Puedes construir un cliente simple con Python o usar la biblioteca oficial mcp de Anthropic (cuando esté disponible para Python). Aquí tienes un cliente básico que envía peticiones y recibe respuestas:

PROMPTimport socket

import json

def send_request(tool_name, params, host="127.0.0.1", port=5000):

request = json.dumps({"tool": tool_name, "params": params})

client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

client.connect((host, port))

client.send(request.encode())

response = client.recv(4096).decode()

client.close()

return json.loads(response)

Ejemplo de uso

if __name__ == "__main__":

# Probar calculadora

result = send_request("calculator", {"operation": "multiply", "a": 7, "b": 6})

print("Calculadora:", result)

# Probar clima

weather = send_request("weather", {"city": "Madrid"})

print("Clima:", weather)

# Generar IDs

ids = send_request("generate_id", {"count": 3})

print("IDs:", ids)

Para integrar tu servidor MCP con Claude u otros asistentes, necesitas exponerlo como un endpoint HTTP (usando Flask o FastAPI) o mantenerlo como socket TCP si tu cliente lo soporta. La ventaja de MCP es que es un estándar abierto: cualquier modelo que entienda el protocolo podrá usar tus herramientas. Buenas prácticas finales: siempre valida los parámetros de entrada en cada handler, usa logging en lugar de print para monitorear, y considera agregar autenticación básica si expones el servidor en red. Tu servidor MCP ya está listo para ser el cerebro de aplicaciones de IA con datos frescos y acciones reales.