Ollama MCP Bridge

Un servicio API puente que conecta Ollama con servidores del Protocolo de Contexto de Modelo (MCP).

GitHub
103
Prueba este MCPPatrocinado

Documentación

Proporciona una capa de API frente a la API de Ollama, integrando sin problemas herramientas de múltiples servidores MCP para que cada solicitud de Ollama pueda acceder a todas las herramientas conectadas de forma transparente.

Ollama MCP Bridge

PyPI - Package Version CI Test Publish Publish Python 3.10+ License

📖 Documentación completa: https://jonigl.github.io/ollama-mcp-bridge/

Instalación, referencia de configuración, notas de arquitectura y referencia de código, todo buscable.

Tabla de Contenidos

Características

  • 🚀 Servidores Precargados: Todos los servidores MCP se conectan al inicio desde la configuración JSON
  • 📝 Configuración JSON: Configura múltiples servidores con comandos y entornos complejos
  • 🌐 Múltiples Tipos de Transporte: Conéctate a servidores MCP mediante stdio (procesos locales), HTTP (StreamableHTTP) o SSE
  • 🎯 Filtrado de Herramientas: Filtra herramientas por servidor con modos de inclusión/exclusión para un control preciso
  • 🧩 Expansión de Variables de Configuración: Soporta ${env:VAR_NAME} y ${workspaceFolder} en cadenas de configuración
  • 🔗 Integración de Herramientas: Procesamiento automático de llamadas a herramientas e integración de respuestas
  • 🔄 Ejecución de Herramientas en Múltiples Rondas: Itera automáticamente a través de múltiples rondas de llamadas a herramientas hasta completar
  • 🛡️ Límites de Herramientas Configurables: Establece rondas máximas de ejecución de herramientas para prevenir llamadas excesivas
  • 🛠️ Todas las Herramientas Disponibles: Ollama puede usar cualquier herramienta de cualquier servidor conectado simultáneamente
  • 🔌 Compatibilidad Completa con la API: /api/chat añade herramientas mientras todos los demás endpoints de la API de Ollama se proxean de forma transparente
  • 🔧 Ollama Configurable: Especifica una URL personalizada del servidor Ollama mediante CLI (soporta modelos locales y en la nube)
  • 🔐 Cabeceras Upstream Opcionales: Envía cabeceras personalizadas fijas (por ejemplo, una clave de API) con cada solicitud al servidor upstream
  • ☁️ Soporte de Modelos en la Nube: Funciona con modelos en la nube de Ollama
  • 🔄 Verificación de Versión: Comprobación automática de versiones más recientes con instrucciones de actualización
  • 🌊 Respuestas en Streaming: Soporta el streaming incremental de respuestas a los clientes
  • 🤔 Modo de Pensamiento: Proxea mensajes intermedios de "pensamiento" desde Ollama y las herramientas MCP
  • ⚡️ Backend FastAPI: API asíncrona moderna con documentación automática
  • 🏗️ Arquitectura Modular: Separación limpia en módulos de CLI, API y gestión de MCP
  • 💻 CLI Typer: Interfaz de línea de comandos limpia con opciones configurables
  • 📊 Registro Estructurado: Utiliza loguru para un registro exhaustivo
  • 📦 Paquete PyPI: Fácilmente instalable mediante pip o uv desde PyPI
  • 🗣️ Configuración del Prompt del Sistema: Permite establecer un prompt del sistema para el comportamiento del asistente
  • 🐳 Imágenes Docker Multi-Arquitectura ✨ NUEVO: Imágenes linux/amd64 y linux/arm64 preconstruidas publicadas en GitHub Container Registry en cada versión

Requisitos

  • Python >= 3.10.15
  • Servidor Ollama en ejecución (local o remoto)
  • Archivo de configuración de servidores MCP con al menos un servidor MCP definido (ver ejemplo abajo)

Instalación

Puedes instalar ollama-mcp-bridge de varias maneras, según tu preferencia:

Inicio Rápido

Instala al instante con uvx:

uvx ollama-mcp-bridge

O bien, instalar desde PyPI con pip

pip install --upgrade ollama-mcp-bridge

O bien, ejecutar con Docker Compose

docker compose up

Esto utiliza el archivo docker-compose.yml incluido que:

  • Construye el bridge desde el código fuente usando el Dockerfile
  • Se conecta a Ollama ejecutándose en la máquina anfitriona (host.docker.internal:11434)
  • Mapea el archivo de configuración desde ./mcp-config.json (incluye un servidor meteorológico simulado para demostración)
  • Expone el puerto 8000 en el anfitrión
  • Permite todos los orígenes CORS (configurable mediante la variable de entorno CORS_ORIGINS)
  • Soporta tiempos de espera configurables para solicitudes a Ollama mediante OLLAMA_PROXY_TIMEOUT

[!TIP] Para omitir la construcción local y usar la imagen preconstruida de GitHub Container Registry en su lugar, reemplaza el bloque build: en docker-compose.yml con:

image: ghcr.io/jonigl/ollama-mcp-bridge:latest

O bien, ejecutar solo con Docker

[!NOTE] ✨ NUEVO: Las imágenes Docker multi-arquitectura preconstruidas (linux/amd64 y linux/arm64) ahora se publican automáticamente en GitHub Container Registry en cada versión. ¡No se requiere construcción local!

Las imágenes multi-arquitectura preconstruidas (linux/amd64 y linux/arm64) se publican en el GitHub Container Registry en cada versión. Etiquetas disponibles:

  • latest — la versión estable más reciente
  • vX.Y.Z — versión específica (por ejemplo, v0.10.0)
  • sha-<commit> — construcción con SHA de commit exacto
docker run -p 8000:8000 \
  -e OLLAMA_URL=http://host.docker.internal:11434 \
  -v "$PWD/mcp-config.json:/mcp-config.json" \
  -v "$PWD/mock-weather-mcp-server:/mock-weather-mcp-server" \
  -w / \
  ghcr.io/jonigl/ollama-mcp-bridge:latest

Banderas clave:

  • -p 8000:8000 — expone el bridge en tu anfitrión en el puerto 8000
  • -e OLLAMA_URL=http://host.docker.internal:11434 — enruta el tráfico de Ollama a la máquina anfitriona (requerido en macOS y Windows; en Linux usa --network host o la IP del anfitrión en su lugar)
  • -v "$PWD/mcp-config.json:/mcp-config.json" — monta tu configuración local en el contenedor
  • -v "$PWD/mock-weather-mcp-server:/mock-weather-mcp-server" — monta el servidor MCP simulado sin :ro para que uv pueda crear su .venv dentro del directorio
  • -w / — establece el directorio de trabajo en / para que las rutas relativas en mcp-config.json se resuelvan correctamente

[!NOTE] En Linux, host.docker.internal puede no resolverse automáticamente. Usa --network host y mantén OLLAMA_URL=http://localhost:11434, o reemplázalo con la IP LAN de tu anfitrión.

O bien, instalar desde el código fuente

# Clone the repository
git clone https://github.com/jonigl/ollama-mcp-bridge.git
cd ollama-mcp-bridge

# Start Ollama (if not already running)
ollama serve

# Run the bridge
uv run ollama-mcp-bridge

Si deseas instalar el proyecto en modo editable (para desarrollo):

# Install the project in editable mode
uv tool install --editable .
# Run it like this:
ollama-mcp-bridge

Cómo Funciona

  1. Inicio: Todos los servidores MCP definidos en la configuración se cargan y conectan
  2. Verificación de Versión: Al inicio, el bridge verifica versiones más recientes y notifica si hay una actualización disponible
  3. Recopilación de Herramientas: Las herramientas de todos los servidores se recopilan y se ponen a disposición de Ollama
  4. Solicitud de Finalización de Chat (solo endpoint /api/chat): Cuando se recibe una solicitud de finalización de chat en /api/chat:
    • La solicitud se reenvía a Ollama (local o en la nube) junto con la lista de todas las herramientas disponibles
    • Si Ollama elige invocar alguna herramienta, esas llamadas se ejecutan a través de los servidores MCP correspondientes
    • Las respuestas de las herramientas se retroalimentan a Ollama
    • El proceso se repite en un bucle hasta que no se necesiten más llamadas a herramientas
    • Las respuestas se transmiten al cliente en tiempo real durante todo el proceso
    • La respuesta final (con todos los resultados de las herramientas integrados) se devuelve al cliente
    • Este es el único endpoint donde se integran las herramientas de los servidores MCP.
  5. Otros Endpoints: Todos los demás endpoints (excepto /api/chat, /health y /version) se proxean completamente al servidor Ollama subyacente sin modificación.
  6. Registro: Todas las operaciones se registran usando loguru para depuración y monitoreo

Configuración

Configuración de Servidores MCP

Puedes configurar servidores MCP de tres maneras:

  • Proceso local (stdio): {"command": "...", "args": [...], "env": {...}}
  • Endpoint remoto (StreamableHTTP): {"url": "https://..."} - Usa StreamableHTTP por defecto
  • Endpoint remoto (SSE): {"url": "https://.../sse"} - Si la URL termina en /sse, el bridge se conecta mediante Server-Sent Events

Crea un archivo de configuración MCP en mcp-config.json con tus servidores:

{
  "mcpServers": {
    "weather": {
      "command": "uv",
      "args": [
        "--directory",
        "./mock-weather-mcp-server",
        "run",
        "main.py"
      ],
      "env": {
        "MCP_LOG_LEVEL": "ERROR"
      },
      "toolFilter": {
        "mode": "include",
        "tools": ["get_current_temperature", "get_forecast"]
      }
    },
    "remote_streamable_http": {
      "url": "https://example.com/mcp"
    },
    "remote_sse": {
      "url": "https://example.com/sse"
    },
    "filesystem": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "/tmp"
      ],
      "toolFilter": {
        "mode": "exclude",
        "tools": ["delete_file", "write_file"]
      }
    }
  }
}

Filtrado de Herramientas

Puedes filtrar qué herramientas de un servidor MCP se ponen a disposición de Ollama usando la configuración opcional toolFilter:

  • toolFilter (opcional): Objeto con opciones de filtrado
    • mode: Ya sea "include" (lista de permitidos) o "exclude" (lista de denegados). Por defecto es "include" si no se especifica.
    • tools: Matriz de nombres exactos de herramientas a incluir o excluir

Comportamiento:

  • Si toolFilter no está configurado o la matriz tools está vacía, se cargan todas las herramientas del servidor (comportamiento por defecto)
  • Modo de inclusión (lista de permitidos): Solo las herramientas listadas en la matriz tools se ponen a disposición. Si una herramienta listada no se encuentra en el servidor, se registra una advertencia pero la conexión del servidor continúa.
  • Modo de exclusión (lista de denegados): Todas las herramientas excepto las listadas en la matriz tools se ponen a disposición. Las herramientas listadas se filtran.
  • Los nombres de las herramientas deben coincidir exactamente (distinguen mayúsculas y minúsculas)
  • Los valores inválidos de mode hacen que la aplicación salga con un mensaje de error

Ejemplo con modo de inclusión (por defecto):

{
  "mcpServers": {
    "weather": {
      "command": "uv",
      "args": ["--directory", "./mock-weather-mcp-server", "run", "main.py"],
      "toolFilter": {
        "tools": ["get_current_temperature", "get_forecast"]
      }
    }
  }
}

Ejemplo con modos explícitos:

{
  "mcpServers": {
    "weather": {
      "command": "uv",
      "args": ["--directory", "./mock-weather-mcp-server", "run", "main.py"],
      "toolFilter": {
        "mode": "include",
        "tools": ["get_current_temperature"]
      }
    },
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/tmp"],
      "toolFilter": {
        "mode": "exclude",
        "tools": ["delete_file", "write_file"]
      }
    }
  }
}

Expansión de Variables

La configuración también soporta expansión simple en cualquier valor de cadena:

  • ${workspaceFolder} se resuelve al directorio que contiene el archivo de configuración
  • ${env:VAR_NAME} se resuelve a la variable de entorno correspondiente

Ejemplo:

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "${workspaceFolder}/data"
      ]
    },
    "remote_with_headers": {
      "url": "https://example.com/mcp",
      "headers": {
        "X-Client-Name": "ollama-mcp-bridge",
        "X-Request-Tag": "${env:MCP_REQUEST_TAG}"
      }
    }
  }
}

[!WARNING] Limitaciones de Comandos Docker: Cuando se ejecuta en Docker, los servidores MCP deben usar comandos disponibles en el contenedor:

  • ✅ npx para servidores MCP basados en Node.js
  • ✅ uvx para servidores MCP basados en Python
  • ✅ Ejecutables directos en el contenedor
  • ❌ Comandos docker (a menos que se configure Docker-in-Docker)
  • ❌ Rutas de archivos locales desde tu máquina anfitriona

Configuración de CORS

Configura el Intercambio de Recursos de Origen Cruzado (CORS) para permitir solicitudes desde tus aplicaciones frontend:

# Allow all origins (default, not recommended for production)
ollama-mcp-bridge

# Allow specific origins
CORS_ORIGINS="http://localhost:3000,https://myapp.com" ollama-mcp-bridge

# Allow multiple origins with different ports
CORS_ORIGINS="http://localhost:3000,http://localhost:8080,https://app.example.com" ollama-mcp-bridge

Registro de CORS:

  • El bridge registra la configuración de CORS al inicio
  • Muestra una advertencia cuando se usa * (todos los orígenes)
  • Muestra los orígenes permitidos cuando está configurado correctamente

[!WARNING] Usar CORS_ORIGINS="*" permite todos los orígenes y no se recomienda para producción. Siempre especifica orígenes exactos por seguridad.

Variables de Entorno

  • CORS_ORIGINS: Lista separada por comas de orígenes permitidos (predeterminado: *)
    • * permite todos los orígenes (muestra una advertencia en los registros)
    • Ejemplo: CORS_ORIGINS="http://localhost:3000,https://myapp.com" ollama-mcp-bridge
  • MAX_TOOL_ROUNDS: Número máximo de rondas de ejecución de herramientas (predeterminado: ilimitado)
    • Se puede sobrescribir con el parámetro CLI --max-tool-rounds (el CLI tiene prioridad)
    • Ejemplo: MAX_TOOL_ROUNDS=5 ollama-mcp-bridge
  • OLLAMA_URL: URL del servidor Ollama (predeterminado: http://localhost:11434)
    • Se puede sobrescribir con el parámetro CLI --ollama-url
    • Útil para despliegues en Docker y gestión de configuración
    • Ejemplo: OLLAMA_URL=http://192.168.1.100:11434 ollama-mcp-bridge
  • UPSTREAM_HEADERS: Objeto JSON opcional de encabezados para enviar al servidor ascendente (por ejemplo, para autenticación con clave API)
    • Estos encabezados no son consumidos por Ollama en sí, sino por lo que se encuentre entre el puente y Ollama (proxy inverso / puerta de enlace / capa de autenticación) — el ascendente
    • Se pueden extender/sobrescribir por encabezado con el parámetro CLI repetible --upstream-header (el CLI tiene prioridad)
    • Útil para despliegues en Docker donde los encabezados no deberían aparecer en la lista de procesos
    • Ejemplo: UPSTREAM_HEADERS='{"Authorization": "Bearer token123", "X-API-Key": "secret"}' ollama-mcp-bridge
  • OLLAMA_PROXY_TIMEOUT: Tiempo de espera para solicitudes HTTP enviadas a Ollama, en milisegundos (predeterminado: sin establecer)
    • Cuando no está establecido, el puente mantiene su comportamiento existente (algunas solicitudes usan los valores predeterminados de la biblioteca; /api/chat no tiene tiempo de espera)
    • Cuando se establece a un valor > 0, el tiempo de espera se aplica a las solicitudes HTTP dirigidas a Ollama
    • Cuando se establece a 0, los tiempos de espera se desactivan para las solicitudes HTTP de Ollama (el puente registra una advertencia)
    • Las respuestas de chat en streaming siempre usan sin tiempo de espera, incluso cuando esta variable está establecida
    • Ejemplo (10 minutos): OLLAMA_PROXY_TIMEOUT=600000 ollama-mcp-bridge
  • SYSTEM_PROMPT: Mensaje de sistema opcional para anteponer a todas las solicitudes /api/chat reenviadas
    • Se puede establecer mediante la variable de entorno SYSTEM_PROMPT o la bandera CLI --system-prompt
    • Si se proporciona, el puente antepondrá un mensaje de sistema (rol: system) al inicio del arreglo messages para solicitudes /api/chat a menos que la solicitud ya comience con un mensaje de sistema.
    • Ejemplo: SYSTEM_PROMPT="You are a concise assistant." ollama-mcp-bridge

Uso

[!NOTA] Se proporciona un script de servidor MCP de ejemplo en mock-weather-mcp-server/main.py.

Iniciar el Servidor

# Start with default settings (config: ./mcp-config.json, host: 0.0.0.0, port: 8000)
ollama-mcp-bridge

# Start with custom configuration file
ollama-mcp-bridge --config /path/to/custom-config.json

# Custom host and port
ollama-mcp-bridge --host 0.0.0.0 --port 8080

# Custom Ollama server URL (local or cloud)
ollama-mcp-bridge --ollama-url http://192.168.1.100:11434

# Send custom header(s) to the upstream server (repeatable, curl-style "Name: Value")
ollama-mcp-bridge --upstream-header "X-API-Key: your-key"
ollama-mcp-bridge --upstream-header "Authorization: Bearer xxx" --upstream-header "X-API-Key: yyy"

# Keep the secret out of your shell history by letting the shell expand an env var
ollama-mcp-bridge --upstream-header "Authorization: Bearer $MY_API_KEY"

# Limit tool execution rounds (prevents excessive tool calls)
ollama-mcp-bridge --max-tool-rounds 5

# Set a system prompt to prepend to all /api/chat requests
ollama-mcp-bridge --system-prompt "You are a concise assistant."

# Combine options
ollama-mcp-bridge --config custom.json --host 0.0.0.0 --port 8080 --ollama-url http://remote-ollama:11434 --max-tool-rounds 10

# Combine options with an upstream API key header
ollama-mcp-bridge --config custom.json --ollama-url http://remote-ollama:11434 --upstream-header "X-API-Key: your-key" --port 8080

# Check version and available updates
ollama-mcp-bridge --version

[!CONSEJO] Si se usa uvx para ejecutar el puente, se debe especificar el comando como uvx ollama-mcp-bridge en lugar de solo ollama-mcp-bridge.

[!NOTA] Este puente admite tanto respuestas en streaming como modo de pensamiento. Se reciben respuestas incrementales a medida que se generan, con llamadas a herramientas y mensajes de pensamiento intermedios automáticamente proxy entre Ollama y todas las herramientas MCP conectadas.

Opciones del CLI

  • --config: Ruta al archivo de configuración MCP (predeterminado: mcp-config.json)
  • --host: Host para vincular el servidor (predeterminado: 0.0.0.0)
  • --port: Puerto para vincular el servidor (predeterminado: 8000)
  • --ollama-url: URL del servidor Ollama (predeterminado: http://localhost:11434)
  • --upstream-header: Encabezado para enviar al servidor ascendente como "Name: Value" (repetible; también se puede establecer mediante la variable de entorno UPSTREAM_HEADERS)
  • --max-tool-rounds: Rondas máximas de ejecución de herramientas (predeterminado: ilimitado)
  • --reload: Habilitar recarga automática durante el desarrollo
  • --version: Mostrar información de versión, buscar actualizaciones y salir
  • --system-prompt: Mensaje de sistema opcional para anteponer a solicitudes /api/chat (predeterminado: ninguno)

Cuando se configuran, los encabezados ascendentes personalizados se agregan a las verificaciones de salud del puente y a todas las solicitudes que el puente envía al servidor ascendente, incluidos /api/chat y los endpoints de Ollama proxy de forma transparente.

Uso de la API

La API está disponible en http://localhost:8000.

  • Documentación de Swagger UI: http://localhost:8000/docs
  • Endpoints compatibles con Ollama:
    • POST /api/chat — Endpoint de chat (igual que la API de Ollama, pero con soporte de herramientas MCP)
      • Este es el único endpoint donde se integran las herramientas del servidor MCP. Todas las llamadas a herramientas se manejan y las respuestas se fusionan de forma transparente para el cliente.
    • Todos los demás endpoints (excepto /api/chat, /health y /version) se proxy completamente al servidor Ollama subyacente sin modificación. Se pueden usar los clientes y bibliotecas Ollama existentes como de costumbre.
  • Endpoints específicos del puente:
    • GET /health — Endpoint de verificación de salud (no proxy)
    • GET /version — Información de versión y verificación de actualizaciones

[!IMPORTANTE] /api/chat es el único endpoint con integración de herramientas MCP. Todos los demás endpoints se proxy de forma transparente a Ollama. /health y /version son específicos del puente.

Este puente actúa como un proxy de reemplazo directo para la API de Ollama, pero con todas las herramientas MCP de todos los servidores conectados disponibles para cada solicitud /api/chat. El puente maneja automáticamente múltiples rondas de ejecución de herramientas hasta completarse, transmitiendo respuestas en tiempo real. Se pueden usar los clientes y bibliotecas Ollama existentes con modelos Ollama locales y en la nube, solo hay que apuntarlos a este puente en lugar del servidor Ollama.

Ejemplo: Chat

curl -N -X POST http://localhost:8000/api/chat \
  -H "accept: application/json" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "qwen3:0.6b",
    "messages": [
      {
        "role": "system",
        "content": "You are a weather assistant."
      },
      {
        "role": "user",
        "content": "What is the weather like in Paris today?"
      }
    ],
    "think": true,
    "stream": true,
    "options": {
      "temperature": 0.7,
      "top_p": 0.9
    }
  }'

[!CONSEJO] Use /docs para exploración y prueba interactiva de la API.

Desarrollo

Dependencias Clave

  • FastAPI: Marco web moderno para la API
  • Typer: Marco CLI para la interfaz de línea de comandos
  • loguru: Registro estructurado en toda la aplicación
  • ollama: Cliente Python para comunicación con Ollama
  • mcp: Biblioteca cliente del Protocolo de Contexto de Modelo
  • pytest: Marco de pruebas para validación de API

Pruebas

El proyecto tiene dos tipos de pruebas:

Pruebas Unitarias (compatibles con GitHub Actions)

# Install test dependencies
uv sync --extra test

# Run unit tests (no server required)
uv run pytest tests/test_unit.py -v

Estas pruebas verifican:

  • Carga de archivos de configuración
  • Importaciones e inicialización de módulos
  • Estructura del proyecto
  • Formatos de definición de herramientas

Pruebas de Integración (requieren servicios en ejecución)

# First, start the server in one terminal
ollama-mcp-bridge

# Then in another terminal, run the integration tests
uv run pytest tests/test_api.py -v

Estas pruebas verifican:

  • Endpoints de API con solicitudes HTTP reales
  • Funcionalidad de extremo a extremo con Ollama
  • Llamadas a herramientas e integración de respuestas

Pruebas Manuales

# Quick manual test with curl (server must be running)
curl -X GET "http://localhost:8000/health"

# Check version information and update status
curl -X GET "http://localhost:8000/version"

curl -X POST "http://localhost:8000/api/chat" \
  -H "Content-Type: application/json" \
  -d '{"model": "qwen3:0.6b", "messages": [{"role": "user", "content": "What tools are available?"}]}'

[!NOTA] Las pruebas requieren que el servidor esté ejecutándose en localhost:8000. Asegúrese de iniciar el servidor antes de ejecutar pytest.

Contribuciones

¡Agradecemos las contribuciones! Consulte CONTRIBUTING.md para:

  • Instrucciones de configuración de desarrollo
  • Pautas de formato de código (Black)
  • Procedimientos de prueba
  • Convenciones de commits

Proyectos Relacionados

  • Cliente MCP para Ollama - Un cliente de interfaz de usuario basada en texto (TUI) para interactuar con servidores MCP usando Ollama. Las características incluyen soporte de múltiples servidores, cambio dinámico de modelos, respuestas en streaming, gestión de herramientas, capacidades de humano en el bucle, modo de pensamiento, configuración completa de parámetros de modelos, mensaje de sistema personalizado y preferencias guardadas. Diseñado para desarrolladores que trabajan con LLM locales.

  • simple-ollama-chat – Un cliente de chat simple y fácil de usar para Ollama que funciona perfectamente con el Puente MCP de Ollama. Permite interactuar con modelos y usar todas las herramientas del servidor MCP integradas a través del puente, con una interfaz limpia y configuración sencilla. Ideal para probar rápidamente, chatear y explorar LLM aumentados con herramientas a través del puente.

Inspiración y Créditos

Este proyecto se basa en el cliente MCP básico de mi artículo en Medium: Construye un Cliente MCP en Minutos: Los Agentes de IA Locales Se Vuelven Reales.

La inspiración para crear este puente simple provino de este problema de GitHub: jonigl/mcp-client-for-ollama#22, sugerido por @nyomen.

Hecho con ❤️ por jonigl