Crea un servidor MCP en Python y conéctalo a Claude Desktop y SQLite.

Cualquiera que desarrolle agentes empresariales conoce el problema de tener que escribir código de enlace. Un wrapper para la base de datos, otra capa de integración para tickets de Jira, otra para Slack. Si se multiplica eso por diez bases de datos y cinco frameworks de LLM como Claude, AutoGen y LangChain, el diseño colapsa bajo su propio peso. Este es el problema de integración N por M: la IA debe comprender la forma exacta de cada fuente de datos con la que interactúa.

El Protocolo de Contexto de Modelo (MCP) es un estándar abierto diseñado específicamente para resolver ese problema. Imagine un cable USB-C universal para la IA. La conexión a la base de datos se escribe una sola vez y se expone a través de un servidor estandarizado único, permitiendo que cualquier cliente compatible se conecte, descubra las herramientas disponibles y las utilice. A continuación se muestra un servidor MCP local con menos de 50 líneas de Python, conectado a Claude Desktop y respaldado por una base de datos SQLite en tiempo real.

Requisitos previos

El paquete oficial de Python mcp se encarga de la mayor parte del trabajo. Oculta los detalles de JSON-RPC, por lo que un solo decorador es suficiente para exponer una herramienta al modelo. Primero instálalo en tu entorno virtual:

pip install mcp

También es necesario instalar Claude Desktop en la máquina.

Escribir el servidor

Cree un archivo llamado mcp_server.py, importe las bibliotecas e inicialice el servidor. Hay un detalle importante aquí: el módulo os fija el archivo SQLite en el mismo directorio que el script. Claude Desktop inicia el servidor en segundo plano, y sin una ubicación fija es posible que aparezcan errores de permisos.

import sqlite3
import json
import os
import sys
from mcp.server.mcpserver import MCPServer

# Initialize the MCP server
mcp = MCPServer(name="Enterprise_SQL_Agent")

# Force the database to be created in the exact same folder as this script
BASE_DIR = os.path.dirname(os.path.abspath(__file__))
DB_PATH = os.path.join(BASE_DIR, "enterprise.db")

A continuación se crea una base de datos temporal para que el modelo tenga algo sobre lo cual consultar. La configuración del registro se dirige al error estándar (sys.stderr). La salida estándar es el canal que MCP utiliza para comunicarse con el cliente, y las impresiones no deseadas allí podrían dañarlo.

def setup_dummy_db():
    """Create a sample employee database for the demo"""
    try:
        conn = sqlite3.connect(DB_PATH)
        cursor = conn.cursor()

        cursor.execute('''CREATE TABLE IF NOT EXISTS employees
                          (id INTEGER PRIMARY KEY, name TEXT, role TEXT, salary INTEGER)''')
        cursor.execute("DELETE FROM employees")

        employees = [
            ("Alice", "Data Scientist", 120000),
            ("Bob", "DevOps Engineer", 115000),
            ("Charlie", "AI Researcher", 135000)
        ]

        cursor.executemany("INSERT INTO employees (name, role, salary) VALUES (?, ?, ?)", employees)
        conn.commit()
        conn.close()
        print("Database initialized successfully.", file=sys.stderr)
    except Exception as e:
        print(f"Database setup error: {e}", file=sys.stderr)

Exponer la base de datos como una herramienta

El paso fundamental es una función ordinaria de Python que ejecuta una consulta SQL y devuelve las filas. Al agregar el decorador @mcp.tool(), el servidor lee la documentación y las indicaciones de tipo para crear automáticamente un esquema JSON para el modelo.

@mcp.tool()
def query_employee_database(sql_query: str) -> str:
    """
    Executes a SQL SELECT query against the enterprise.db database.

    The database contains an 'employees' table with columns:
    - id (INTEGER PRIMARY KEY)
    - name (TEXT)
    - role (TEXT)
    - salary (INTEGER)

    SECURITY: Only READ operations (SELECT) are permitted.
    """

    # Safety Check: Block destructive SQL commands
    dangerous_keywords = ["DROP", "DELETE", "UPDATE", "INSERT", "ALTER"]
    if any(keyword in sql_query.upper() for keyword in dangerous_keywords):
        return "Error: Only SELECT queries are authorized for this tool."

    try:
        conn = sqlite3.connect(DB_PATH)
        cursor = conn.cursor()
        cursor.execute(sql_query)
        results = cursor.fetchall()

        # Format the output as JSON so the LLM can read it cleanly
        column_names = [description[0] for description in cursor.description]
        formatted_results = [dict(zip(column_names, row)) for row in results]

        conn.close()
        return json.dumps(formatted_results, indent=2)

    except Exception as e:
        return f"Database error: {str(e)}"

Un breve bloque de inicio finaliza el archivo:

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

Conectar Claude Desktop

Es necesario indicarle al cliente dónde se encuentra el servidor. En Windows, vaya a la carpeta %APPDATA%\Claude, abra claude_desktop_config.json en un editor y agregue una entrada mcpServers.

Un detalle en Windows que confunde a muchos: si ejecuta el programa dentro de un entorno virtual como Conda o venv, indique la ruta absoluta de python.exe de ese entorno en lugar del comando global simple python, y escriba todas las rutas con dobles barras invertidas.

{
  "mcpServers": {
    "enterprise-sql": {
      "command": "C:\\Users\\YourName\\.conda\\envs\\your_env\\python.exe",
      "args": [
        "D:\\Your\\Project\\Path\\mcp_server.py"
      ]
    }
  }
}

Guarde el archivo y reinicie completamente Claude Desktop.

Viendo cómo funciona

Abra Claude Desktop y busque el ícono del martillo (Herramientas) en la esquina inferior derecha del cuadro de chat. La herramienta query_employee_database ya debería aparecer allí registrada. Una buena prueba inicial es preguntar quién gana más en la tabla de empleados y qué puesto ocupa esa persona.

El modelo lee la descripción de la herramienta, escribe el propio SQL (SELECT * FROM employees ORDER BY salary DESC LIMIT 1;), lo ejecuta a través de su servidor y convierte el resultado en una respuesta en lenguaje sencillo. No se escribió ninguna capa API personalizada, y el esquema se descubrió de forma dinámica.

El mismo patrón se aplica a Slack, Jira, GitHub o cualquier API interna de la empresa, y eso es lo que cambia la economía de desarrollo de sistemas agentes en una empresa: cada sistema se envuelve una sola vez, y cualquier asistente compatible puede utilizarlo.

Leer más

• Notas prácticas: ¿Puede su agente buscar MCPs? — Guía paso a paso de Notas prácticas: ¿Puede su agente buscar MCPs?: contratos, verificaciones y espacios de código listos para uso para equipos que implementan este patrón.
• WebMCP: exponer herramientas de sitio web para que los agentes dejen de escanear el DOM — WebMCP permite a las páginas declarar herramientas estructuradas para agentes de IA: APIs imperativas y declarativas, de modo que los procesos de reserva y salida dejen de depender de una automatización del navegador frágil.