Usar MCP con Ollama

Qué abarca este artículo sobre MCP y Ollama

• Qué es el Model Context Protocol.
• Cómo se proporcionan herramientas y contexto a través de MCP.
• Cómo utilizar Ollama con flujos de trabajo similares a MCP.
• Ejemplos de herramientas, prompts del sistema y llamadas a funciones.
• Consejos para implementaciones locales.

Introducción: Usar MCP con Ollama

MCP significa Model Context Protocol. Es un estándar abierto que permite a los modelos de lenguaje utilizar de forma estructurada herramientas externas, fuentes de datos y contextos. En lugar de meter todo en el prompt, los modelos pueden invocar funciones de manera selectiva, procesar resultados y resolver tareas más complejas. Con Ollama es posible construir un comportamiento similar integrando herramientas en la solicitud API e interpretando las respuestas del modelo.

Este artículo presenta la idea detrás de MCP, cómo se definen las herramientas y cómo implementar un ejemplo simple con Ollama.

Términos clave

• MCP: Model Context Protocol.
• Tool: Función externa que el modelo puede invocar.
• Function Calling: El modelo decide qué función desea llamar.
• Schema: Descripción de una función y sus parámetros.
• Context: Información adicional proporcionada al modelo.
• Agent: Sistema que combina el modelo, herramientas y lógica.
• Server: Componente que proporciona las herramientas.
• Client: Aplicación que envía solicitudes al servidor MCP y al modelo.

Para qué sirve MCP

MCP ayuda a:

• Proporcionar a los modelos datos actualizados.
• Acceder a archivos locales, bases de datos o APIs.
• Ejecutar cálculos o realizar acciones.
• Automatizar tareas repetitivas.
• Habilitar flujos de trabajo de múltiples etapas.

En lugar de esperar que un modelo memorice todo, obtiene información del entorno bajo demanda.

Definir herramientas

Una herramienta se describe mediante un esquema JSON. Ejemplo para una función de clima:

{
  "type": "function",
  "function": {
    "name": "get_weather",
    "description": "Devuelve el clima actual para una ubicación.",
    "parameters": {
      "type": "object",
      "properties": {
        "location": {
          "type": "string",
          "description": "Ciudad u ubicación"
        }
      },
      "required": ["location"]
    }
  }
}

Ollama y Function Calling

Ollama no ofrece un servidor MCP nativo, pero admite la inclusión de herramientas a través del formato de chat. El modelo proporciona en ciertos modelos un formato de respuesta especial que se puede interpretar como una llamada a función.

Ejemplo con Python

import ollama
import json

weather_schema = {
    "name": "get_weather",
    "description": "Devuelve el clima actual para una ubicación.",
    "parameters": {
        "type": "object",
        "properties": {
            "location": {"type": "string"}
        },
        "required": ["location"]
    }
}

def get_weather(location):
    return f"El clima en {location} es soleado y 22 grados."

messages = [
    {"role": "user", "content": "¿Cómo es el clima en Berlín?"}
]

response = ollama.chat(
    model="qwen2.5:14b",
    messages=messages,
    tools=[weather_schema]
)

print(response["message"]["content"])

Si el modelo codifica la invocación de herramienta en su respuesta, la aplicación puede ejecutar la función y devolver el resultado.

Flujo de trabajo de dos pasos

import re

answer = response["message"]["content"]
match = re.search(r"get_weather\(.*location=[\"'](.+?)[\"']\)", answer)

if match:
    location = match.group(1)
    result = get_weather(location)

    messages.append({"role": "assistant", "content": answer})
    messages.append({"role": "tool", "content": result})

    final = ollama.chat(model="qwen2.5:14b", messages=messages)
    print(final["message"]["content"])

Importante: el formato de la invocación de herramienta depende del modelo. Los modelos especializados en herramientas entregan respuestas más estructuradas.

Construir un servidor MCP

Un servidor MCP proporciona herramientas y comunica a través de un protocolo estandarizado. Para Ollama se puede escribir un servidor Python simple que intercambie esquemas JSON y resultados sobre HTTP:

from fastapi import FastAPI

app = FastAPI()

@app.get("/tools")
def tools():
    return [weather_schema]

@app.post("/call")
def call(payload: dict):
    if payload["name"] == "get_weather":
        return get_weather(payload["args"]["location"])

Aplicaciones prácticas

• RAG: El modelo recupera secciones de documentos relevantes.
• Búsqueda de archivos: El modelo busca en un directorio.
• Calendario: El modelo lee o escribe eventos.
• Información del sistema: El modelo consulta el uso de CPU o RAM.
• Acceso a API: El modelo obtiene datos de APIs locales o externas.

Consejos

• Usar esquemas claros con buenas descripciones.
• Pocas herramientas precisas producen mejores resultados que muchas documentadas deficientemente.
• Validar invocaciones de herramientas antes de ejecutarlas.
• Considerar seguridad: nunca ejecutar comandos sin verificar.
• Capturar casos de error y devolverlos al modelo como contexto.
• Mantener registros para poder reconstruir los flujos de trabajo.

Errores comunes

• El modelo no admite Function Calling: La salida no es estructurada.
• Formato incorrecto: El modelo inventa su propia sintaxis de función.
• Demasiadas herramientas: El modelo se sobrecarga.
• Descripción faltante: El modelo elige la herramienta equivocada.
• Vulnerabilidades de seguridad: La herramienta ejecuta comandos arbitrarios.
• Llamadas circulares: El modelo invoca herramientas sin fin.
• Lógica de timeout ausente: Las llamadas externas bloquean el flujo de trabajo.

Enlaces e información adicional

• BotServ.de Bibliotecas de API de Ollama
• BotServ.de Ollama para Coding
• BotServ.de RAG con Ollama
• BotServ.de Memoria de agentes

FAQ: MCP con Ollama

¿Ollama soporta MCP de forma nativa? No como servidor, pero las herramientas se pueden incluir a través del formato de chat.

¿Qué modelos son adecuados para Function Calling? qwen2.5, mistral y modelos entrenados específicamente para herramientas suelen proporcionar resultados utilizables.

¿Necesito un servidor MCP? Solo si múltiples aplicaciones deben usar las mismas herramientas. A menudo es suficiente un bucle Python simple.

¿Es MCP seguro? El protocolo es tan seguro como las herramientas implementadas. Siempre validar entradas.

¿Puedo usar MCP con Open WebUI? Open WebUI ofrece sus propias funciones de herramientas. La integración directa de MCP puede variar según la versión.

Fuentes y lecturas adicionales

• MCP Spec: https://modelcontextprotocol.io/
• Ollama API: https://github.com/ollama/ollama/blob/main/docs/api.md
• LangChain Tools: https://python.langchain.com/docs/modules/agents/tools/

Resumen: Usar MCP con Ollama

MCP amplía los modelos de lenguaje locales con herramientas, fuentes de datos y contexto dinámico. Ollama permite flujos de trabajo similares a través de prompts tipo Function Calling e interpretación de respuestas del modelo. Quien implemente esquemas claros, lógica de ejecución segura y un flujo de trabajo de dos pasos bien pensado, puede convertir Ollama en un agente amigable con la privacidad que tenga acceso a herramientas. La combinación con RAG, APIs y datos del sistema local es especialmente interesante.