MCP y LLM local: conectar servidores MCP a Ollama

#¿Qué es MCP y por qué cambia a los agentes locales?

MCP (Model Context Protocol) es un protocolo abierto publicado por Anthropic a finales de 2024. Su objetivo: ofrecer una interfaz única entre un modelo de lenguaje y las herramientas que puede utilizar. En lugar de volver a programar una integración propia para cada fuente de datos, un «servidor MCP» expone herramientas (tools), recursos (resources) y prompts según un formato estándar. Cualquier cliente compatible —Claude Desktop, un IDE o tu propio puente— puede entonces conectarse a él.

En concreto, un servidor MCP «filesystem» expone herramientas como read_file, write_file o list_directory. Un servidor «sqlite» expone query o list_tables. El LLM nunca habla directamente con el disco: emite una solicitud de llamada a una herramienta, el cliente la ejecuta a través del servidor MCP y luego devuelve el resultado al modelo. Esta separación entre cliente y servidor es lo que hace que el protocolo sea reutilizable.

Para los agentes locales, el reto es doble: reutilizar el creciente ecosistema de servidores MCP (ya existen decenas) y, al mismo tiempo, mantener la inferencia al 100 % en tu máquina gracias a Ollama. Obtienes un agente que lee tus archivos y consulta tus bases de datos sin que un solo byte salga de tu red.

#¿Por qué conectar MCP a Ollama?

La mayoría de las demos MCP utilizan un modelo en la nube (Claude, GPT). Usar MCP con Ollama en local cambia las cosas en tres aspectos: la confidencialidad (tus archivos y consultas SQL no salen), el costo (ningún token facturado, independientemente del volumen de llamadas a herramientas) y el control (tú eliges el modelo, la cuantización y los servidores autorizados).

Confidencialidad

Un servidor MCP filesystem da al modelo acceso a tus carpetas. Localmente, este contenido nunca pasa por un tercero.

Costo nulo

Los agentes multiplican los intercambios con las herramientas. En la nube, cada turno cuesta tokens; con Ollama, es gratis.

Sin conexión

Una vez descargado el modelo y instalados los servidores MCP, el conjunto funciona sin conexión a internet (excepto los servidores web, por supuesto).

Soberanía

Decides qué herramientas se exponen y puedes auditar cada llamada antes de ejecutarla.

#Prerrequisitos

Ollama instalado

El daemon escucha por defecto en http://localhost:11434. Comprueba con «ollama --version».

Un modelo de uso de herramientas

Cuenta, como mínimo, con un Granite 4.2 8B; idealmente, con un Qwen 3.5 9B para obtener fiabilidad (consulta la siguiente sección).

Python 3.10+

El SDK MCP oficial y el cliente Ollama están en Python.

Node.js (opcional)

Muchos servidores MCP de referencia se lanzan mediante npx (@modelcontextprotocol/server-*).

# Vérifier Ollama
ollama --version
curl http://localhost:11434/api/tags

# Tirer un modèle capable de tool-use
ollama pull qwen3.5:9b

# Environnement Python
python -m venv .venv
source .venv/bin/activate
pip install mcp ollama

#¿Qué modelos locales gestionan correctamente el uso de herramientas?

No todos los modelos rinden igual en la llamada a funciones. Un modelo que «conoce» el formato de las herramientas pero elige mal sus argumentos hará que el agente sea inutilizable. En la práctica, la generación de 2026 (Qwen 3.5, Granite 4.2) permite un uso fiable de herramientas desde los 8-9B, mientras que en 2024 había que apuntar a los 14B. A continuación se presentan modelos de referencia que puedes probar con Ollama y su consumo de VRAM en Q4_K_M.

Qwen 3.5 4B / 9B

Excelente soporte para el uso de herramientas. El 9B (≈6,6 GB de VRAM en Q4, 256k de contexto, visión) es el mejor equilibrio entre fiabilidad y hardware para un agente local.

Granite 4.2 8B

Uso nativo de herramientas sólido y muy eficiente en tokens (≈5,3 GB en Q4, 128k de contexto). Excelente punto de entrada con 6-8 GB de VRAM.

Mistral Small 24B

Llamada a funciones sólida y buen nivel en francés (≈14 GB en Q4). Maneja bien esquemas de herramientas un poco complejos.

Qwen 3.6 35B-A3B

MoE muy confiable en cadenas de llamadas (≈23 GB en Q4, solo 3B activos, por lo tanto rápido). Reservado para GPUs de 24 GB tipo RTX 4090.

Modelos 2-3B

Qwen 3.5 2B o Granite 4.2 3B caben en ≈2 GB, pero su capacidad para usar herramientas se deteriora rápidamente en cuanto hay varias herramientas. Evitar estos modelos para un agente real.

#Puente MCP-Ollama en Python, paso a paso

Ollama no es un cliente MCP nativo. El papel del puente es de intermediario: iniciar un servidor MCP, convertir sus herramientas al formato esperado por la API Ollama, ejecutar el bucle de llamadas a herramientas, luego devolver los resultados al modelo. Se utiliza el SDK MCP oficial (paquete mcp) y el cliente ollama.

1. 01
   1. Iniciar un servidor MCP

   Se inicia un servidor MCP como subproceso a través de stdio. Aquí se utiliza el servidor filesystem oficial, limitado a una carpeta de trabajo que se pasa como argumento.
2. 02
   2. Listar y convertir herramientas

   session.list_tools() devuelve las herramientas MCP. Se transforman al formato « tools » esperado por /api/chat de Ollama (name, description, inputSchema → parameters).
3. 03
   3. Bucle de llamadas a herramientas

   Se envía el mensaje del usuario junto con la lista de herramientas. Si el modelo responde con un tool_call, se ejecuta en el lado de MCP, se vuelve a introducir el resultado y se repite el ciclo hasta obtener una respuesta final.
4. 04
   4. Devolver la respuesta

   Cuando el modelo ya no solicita ninguna herramienta, su última respuesta de texto es el resultado final que se presenta al usuario.

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

MODEL = "qwen3.5:9b"

# Serveur MCP filesystem limité au dossier ./workspace
server = StdioServerParameters(
    command="npx",
    args=["-y", "@modelcontextprotocol/server-filesystem", "./workspace"],
)

def to_ollama_tools(mcp_tools):
    return [{
        "type": "function",
        "function": {
            "name": t.name,
            "description": t.description,
            "parameters": t.inputSchema,
        },
    } for t in mcp_tools]

async def run(prompt: str):
    async with stdio_client(server) as (read, write):
        async with ClientSession(read, write) as session:
            await session.initialize()
            tools = (await session.list_tools()).tools
            ollama_tools = to_ollama_tools(tools)
            messages = [{"role": "user", "content": prompt}]

            while True:
                resp = ollama.chat(
                    model=MODEL,
                    messages=messages,
                    tools=ollama_tools,
                )
                msg = resp["message"]
                messages.append(msg)

                if not msg.get("tool_calls"):
                    return msg["content"]

                for call in msg["tool_calls"]:
                    fn = call["function"]
                    result = await session.call_tool(
                        fn["name"], fn.get("arguments", {}),
                    )
                    text = "".join(c.text for c in result.content
                                    if getattr(c, "text", None))
                    messages.append({
                        "role": "tool",
                        "content": text,
                    })

if __name__ == "__main__":
    print(asyncio.run(run("Liste les fichiers du dossier et résume leur contenu.")))

#Ejemplos de servidores MCP útiles en entornos autoalojados

El interés de MCP radica en el catálogo de servidores listos para usar. A continuación, se muestran los que aportan más valor a un agente local, todos ejecutables mediante npx o pip.

filesystem

Lectura/escritura de archivos en un directorio raíz impuesto. Lo más útil para un agente que trabaje sobre tus documentos.

sqlite / postgres

Consultar una base de datos local en lenguaje natural. Configura la conexión en modo de solo lectura para evitar cualquier modificación.

fetch

Recuperar y convertir una página web en texto. El único que requiere conexión a internet.

git

Explorar un repositorio: log, diff, estado. Útil para un agente de revisión o de documentación de código.

memory

Un almacén persistente de clave-valor que proporciona al agente una memoria de larga duración entre sesiones.

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "./workspace"]
    },
    "sqlite": {
      "command": "uvx",
      "args": ["mcp-server-sqlite", "--db-path", "./data/app.db"]
    }
  }
}

#Las limitaciones reales de los pequeños modelos

Un bridge funcional no garantiza un buen agente. El punto débil sigue siendo el modelo. En los modelos más ligeros (2-4B), varios problemas reaparecen sistemáticamente cada vez que la tarea se complica.

Elección de herramienta incorrecta

El modelo llama a read_file cuando necesita list_directory, o inventa un nombre de herramienta. Frecuente en modelos de menos de 7B.

Argumentos mal formados

Rutas relativas incorrectas, JSON inválido en los argumentos. Un buen prompt de sistema y descripciones claras de las herramientas atenúan el problema.

Secuencias cortas

Los modelos pequeños tienen dificultades después de 2-3 llamadas consecutivas y pierden el hilo del objetivo.

Ignorar el resultado

El modelo llama a una herramienta y luego responde sin tener en cuenta lo que recibió. Síntoma típico de un modelo demasiado ligero.

#Solución de problemas

El modelo no realiza tool_call

Comprueba que admita el uso de herramientas (Qwen 3.5, Granite 4.2) y que el parámetro «tools» se pase correctamente a /api/chat. Un modelo no compatible ignora las herramientas.

« connection refused » en 11434

El demonio de Ollama no está activo. Inícialo («ollama serve») y vuelve a probar «curl http://localhost:11434/api/tags».

El servidor MCP no se inicia

Prueba el comando npx / uvx solo en un terminal. Si falta un servidor Node, se corrige con « npm i -g » del paquete correspondiente.

Bucle infinito de llamadas a herramientas

Agrega un límite de iteraciones en el bucle y registra cada tool_call para detectar el modelo que repite la misma llamada.

#Para ir más allá

MCP se basa en los componentes básicos del ecosistema local. Estas guías relacionadas del sitio complementan esta guía:

Crear un agente de IA local con LangChain y Ollama

Enfoque clásico de agente a través de LangChain, complemento de MCP para coordinar herramientas.

Integrar Ollama a través de la API REST en Python

Entender el endpoint compatible con OpenAI y el function calling que subyacen al puente.

Elegir tu cuantización (Q4, Q5, Q8, FP16)

Hacer que un Qwen 3.5 9B con uso de herramientas quepa en la memoria de tu GPU sin sacrificar la fiabilidad.