Cómo usar el Model Context Protocol (MCP) con Python: guía paso a paso

Cómo conectar tus modelos de IA con bases de datos, APIs y servicios reales usando Python y MCP

Seguro que ya has jugado con modelos de lenguaje tipo ChatGPT, Claude o Gemini. Son geniales para conversar, pero todos comparten una limitación enorme: no pueden hacer nada en el mundo real por sí solos. No pueden conectarse a tu base de datos, llamar a una API o ejecutar un cálculo externo… a menos que los conectemos.

Ahí es donde entra en juego el Model Context Protocol (MCP), un estándar abierto creado por Anthropic que promete ser, literalmente, el “USB-C de la inteligencia artificial”.

En este artículo vamos a ver:

• Qué es MCP y por qué deberías prestarle atención.

• Cómo preparar tu entorno en Python y VS Code.

• Cómo levantar un servidor y un cliente MCP básicos.

• Cómo conectarlo a una base de datos real (SQLite).

• Cómo desplegarlo en DigitalOcean para uso remoto.

• Y, por supuesto, algunas buenas prácticas para no abrir puertas que luego no puedas cerrar.

Qué es el Model Context Protocol (MCP)

Piensa en MCP como en un puente universal entre tu IA y el mundo exterior.

La arquitectura es sencilla:

• Cliente MCP: vive dentro de la aplicación host (Claude Desktop, VS Code con agente, Cursor…). Su trabajo es recibir lo que el modelo necesita y hablar con el servidor.

• Servidor MCP: lo implementa el desarrollador. Expone “tools” (funciones) que el cliente puede invocar. Esas tools hacen cosas: consultar una BD, llamar a una API, ejecutar cálculos…

• Aplicación host: es lo que ve el usuario final, el chat donde escribes. El host coordina las llamadas al modelo y al MCP.

La gracia es que todo esto sigue un protocolo estándar, lo que trae varias ventajas:

• Integración estandarizada → no más integraciones ad-hoc.

• Flexibilidad → puedes cambiar de modelo sin reescribir la lógica.

• Seguridad → los datos sensibles nunca salen de tu infraestructura, porque el servidor MCP es quien accede a ellos.

• Escalabilidad → puedes usar transporte local (stdio) o remoto (WebSockets, SSE, sockets UNIX).

En resumen: con MCP tu asistente de IA deja de ser un loro con buena memoria para convertirse en un ayudante que puede hacer cosas de verdad.

Preparando el entorno en VS Code

Vamos a montar todo en Python + VS Code.

1. Instala Python 3.10+ y VS Code.

2. Extensión de Python en VS Code.

3. Crea el proyecto y un virtualenv:

python -m venv .venv
source .venv/bin/activate  # Mac/Linux
.venv\Scripts\activate     # Windows

4. Instala MCP y utilidades:

pip install mcp python-dotenv

5. Configura tu base de datos. Para este tutorial usaremos SQLite (un simple .db en local).

Listo. Ahora a ensuciarnos las manos con código.

Servidor MCP básico: la calculadora

Un servidor MCP expone herramientas. Empezamos con algo simple: sumar dos números.

from mcp.server.fastmcp import FastMCP

server = FastMCP("Mi Servidor de Ejemplo")

@server.tool(name="sumar", description="Suma dos números enteros y devuelve el resultado")
def sumar(a: int, b: int) -> int:
    return a + b

if __name__ == "__main__":
    server.run()

Este script crea un servidor con un único tool: sumar. Al ejecutarlo, queda escuchando en local listo para que un cliente le mande peticiones.

Cliente MCP básico: hablando con el servidor

El cliente se conecta al servidor y pide usar sus herramientas.

import asyncio
from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client

server_params = StdioServerParameters(command="python", args=["servidor.py"])

async def main():
    async with stdio_client(server_params) as (read_stream, write_stream):
        async with ClientSession(read_stream, write_stream) as session:
            await session.initialize()
            tools = await session.list_tools()
            print("Herramientas disponibles:", [t.name for t in tools.tools])
            a, b = 5, 7
            result = await session.call_tool("sumar", {"a": a, "b": b})
            print(f"Resultado: {a} + {b} = {result}")

if __name__ == "__main__":
    asyncio.run(main())

Ejecutas el cliente y… voilà: el modelo ya tiene acceso a una calculadora vía MCP.

Conexión a una base de datos: SQLite

Un ejemplo real: una base de datos con participantes de un chat y su número de mensajes.

Creamos la BD:

import sqlite3
conn = sqlite3.connect('community.db')
cur = conn.cursor()
cur.execute("CREATE TABLE chatters (name TEXT, messages INTEGER);")
cur.execute("INSERT INTO chatters VALUES ('Alice', 120), ('Bob', 75), ('Carlos', 50);")
conn.commit()
conn.close()

Ahora ampliamos el servidor con una nueva tool:

from mcp.server.fastmcp import FastMCP
import sqlite3

mcp = FastMCP("Servidor BaseDatos")

@mcp.tool(name="get_top_chatters", description="Obtiene los usuarios más activos")
def get_top_chatters():
    conn = sqlite3.connect('community.db')
    cursor = conn.cursor()
    cursor.execute("SELECT name, messages FROM chatters ORDER BY messages DESC")
    results = cursor.fetchall()
    conn.close()
    return [{"name": n, "messages": m} for (n, m) in results]

if __name__ == "__main__":
    mcp.run()

El cliente ahora puede preguntar: “¿Quién es el más activo en el chat?” y obtendrá la lista con mensajes contados.

Por si no quieres andar copiando y pegando, te he dejado todo el código en el siguiente repo:

Despliegue en DigitalOcean

Trabajar en local está bien, pero lo interesante es desplegarlo para uso remoto. Una opción sencilla: DigitalOcean App Platform.

1. Prepara un requirements.txt con tus dependencias.

2. Añade .env y .db al .gitignore.

3. Crea un Dockerfile:

FROM python:3.11-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
CMD ["python", "servidor_bd.py"]

4. Sube tu repo a GitHub y conéctalo en DigitalOcean.

5. Despliega en un plan básico ($5/mes suele valer).

6. Obtendrás un endpoint remoto para conectar desde Claude, VS Code o cualquier host compatible con MCP.

Te dejo aquí un artículo donde explico como hacerlo con más detalle

Buenas prácticas (no seas el que abre la caja de Pandora)

• Valida entradas → nunca metas input de usuario sin sanitizar en SQL (adiós inyección).

• Cuidado con eval → si permites ejecutar código arbitrario, prepárate para ataques.

• Manejo de credenciales → siempre en variables de entorno, nunca en el repo.

• Restringe accesos → si expones tu servidor remoto, protégelo con autenticación o firewalls.

• Logs y monitoreo → imprime en local, pero en producción usa logging serio.

• Actualiza dependencias → MCP evoluciona rápido, no te quedes con la beta.

Conclusión

El Model Context Protocol (MCP) abre un mundo nuevo para los desarrolladores: asistentes de IA que ya no solo responden, sino que actúan.

Con lo que hemos visto hoy, puedes:

• Crear tu primer servidor y cliente MCP.

• Conectar modelos a una base de datos real.

• Desplegar tu servidor en la nube.

Esto es solo el principio. MCP permite que tu IA se convierta en un verdadero copiloto técnico o de negocio, siempre bajo tu control.

¿Lo mejor? No dependes de integraciones raras ni de APIs propietarias: es un estándar abierto.