Ollama + MCP: modelos locales con herramientas

Aprende a ejecutar modelos de lenguaje localmente con Ollama y conéctalos a herramientas MCP para potenciar tus agentes de IA sin depender de la nube.

¿Por qué modelos locales con MCP?

Combinar modelos locales con el protocolo MCP te da lo mejor de ambos mundos: la autonomía de ejecutar la IA en tu máquina y la capacidad de usar herramientas reales (archivos, terminal, APIs) a través del mismo estándar que usan los modelos en la nube.

• Privacidad total — tus datos nunca salen de tu ordenador. Ideal para código sensible, documentos personales o proyectos bajo NDA
• Coste cero — sin tokens de API, sin suscripciones. Usa tu GPU o CPU tantas horas como quieras
• Offline — funciona sin conexión a Internet. Lleva tu asistente al avión, al campo o a una sala aislada
• Mismo protocolo — los MCPs que configuras para OpenAI o Anthropic funcionan igual con Ollama. Cambias el backend, no las herramientas

Instalar Ollama

Ollama es el gestor de modelos locales más sencillo. En macOS lo instalas con Homebrew:

brew install ollama
ollama serve

Una vez arrancado, descarga los modelos que necesites. Para tool calling necesitas modelos con buen soporte de funciones:

ollama pull llama3.2:3b
ollama pull qwen2.5-coder:7b
ollama pull mistral
ollama pull deepseek-coder

Puedes verificar que funciona con ollama list. Ollama expone una API en http://localhost:11434 compatible con OpenAI.

OpenCode + Ollama

OpenCode soporta Ollama como proveedor nativo. Configúralo en tu opencode.json junto con los MCPs que quieras usar:

{
  "provider": "ollama",
  "model": "qwen2.5-coder:7b",
  "ollamaUrl": "http://localhost:11434",
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "."]
    },
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_TOKEN": "ghp_..."
      }
    }
  }
}

Con esto, OpenCode usa el modelo local para todas las conversaciones y los MCPs le dan acceso al sistema de archivos y a GitHub. Cada vez que la IA necesite leer un archivo o listar un directorio, llamará automáticamente al servidor filesystem.

Continue.dev + Ollama

Continue.dev es el asistente de código abierto para VS Code y JetBrains. Soporta Ollama como backend y MCPs como fuente de herramientas. La configuración va en .continuerc.json o en la UI de ajustes:

{
  "models": [
    {
      "title": "Qwen Coder Local",
      "provider": "ollama",
      "model": "qwen2.5-coder:7b",
      "apiBase": "http://localhost:11434"
    }
  ],
  "experimental": {
    "mcpServers": {
      "filesystem": {
        "command": "npx",
        "args": ["-y", "@modelcontextprotocol/server-filesystem", "."]
      },
      "playwright": {
        "command": "npx",
        "args": ["-y", "@anthropic/mcp-server-playwright"]
      }
    }
  },
  "tabAutocompleteModel": {
    "title": "Starcoder Local",
    "provider": "ollama",
    "model": "starcoder2:3b"
  }
}

Con esta configuración, el modelo Qwen local te da autocompletado, chat contextual y capacidad de ejecutar herramientas MCP directamente desde el editor.

Cline + Ollama

Cline es la extensión de VS Code que convierte al editor en un agente autónomo. Usa la configuración de cline_mcp_settings.json:

{
  "apiProvider": "ollama",
  "model": "qwen2.5-coder:7b",
  "ollamaBaseUrl": "http://localhost:11434",
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "."]
    },
    "terminal": {
      "command": "npx",
      "args": ["-y", "@nicholasgriffintn/mcp-terminal"]
    },
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_TOKEN": "ghp_..."
      }
    }
  }
}

Cline ejecuta tareas multi-paso: lee archivos, ejecuta comandos, crea PRs. Con Ollama como backend todo ocurre localmente.

Ejemplo práctico

Imagina que acabas de clonar un proyecto y quieres entender su estructura sin leer archivo por archivo. Con Ollama + Filesystem MCP puedes pedirle a la IA:

"Analiza la estructura de este proyecto.
Primero lista los archivos raíz, luego lee el package.json
y el README. Después dime de qué trata el proyecto,
qué stack usa y cómo arrancarlo."

El agente hará esto automáticamente:

• Llama a list_directory para ver la raíz del proyecto
• Llama a read_file sobre package.json y README.md
• Analiza el contenido con el modelo local
• Te devuelve un resumen completo con stack, scripts y dependencias

Todo esto sin enviar ni una línea de tu código a la nube. El modelo local procesa los archivos que el MCP filesystem le entrega.

Qué modelos funcionan mejor

No todos los modelos locales manejan bien tool calling. Estos son los que mejor funcionan con MCP:

• Qwen2.5-Coder (7B) — el mejor para tool calling en local. Sigue instrucciones con precisión, entiende cuándo llamar herramientas y genera código de calidad. La opción más equilibrada
• Llama 3.2 (3B) — ligero y rápido. Funciona bien en CPU. Tool calling básico pero efectivo para tareas sencillas como leer archivos o buscar texto
• DeepSeek Coder (6.7B) — excelente para código. Sus respuestas técnicas son detalladas, aunque a veces pierde precisión en llamadas multi-herramienta
• Mistral (7B) — rápido y consistente. Buen soporte de tool calling, ideal como opción polivalente cuando alternas entre código y tareas generales

Limitaciones

• Consistencia de tool calling — los modelos locales no siempre deciden llamar a la herramienta correcta. A veces ignoran un MCP disponible o llaman a la herramienta equivocada. Los modelos cloud (GPT-4o, Claude) son más fiables en este aspecto
• Ventana de contexto — los modelos locales tienen contextos más reducidos (4K-32K tokens). Si el MCP devuelve mucha información, el modelo puede olvidar instrucciones anteriores
• Velocidad — sin GPU dedicada, los modelos de 7B pueden tardar segundos en responder. En cloud obtienes respuestas en milisegundos. Para tareas largas con múltiples llamadas MCP la diferencia se nota
• Modelos pequeños — los modelos de 3B o 7B entienden herramientas simples pero se confunden con workflows complejos que requieren varias herramientas encadenadas