Local AI MCP Servers

Dos servidores MCP autoalojados: gestionan una máquina de modelos local (Ollama pull/switch, entrenamiento LoRA) y conectan con Ollama/vLLM local para tareas de lenguaje.

GitHubPrueba este MCPPatrocinado

Documentación

Servidores MCP de Local-AI: gestión de modelos Ollama y vLLM y acceso local a LLM para Claude, ChatGPT y otros clientes MCP

Dos servidores autoalojables del Protocolo de Contexto de Modelos (MCP) para ejecutar y dirigir tus propios modelos de lenguaje locales: gestiona una máquina de modelos Ollama/vLLM y consulta un LLM local (Ollama, vLLM o un backend compatible con OpenAI) para tareas de lenguaje con salida JSON validada por esquema. Autoalojados y centrados en la privacidad: los modelos y su máquina permanecen en tu propio hardware, y ninguno de los procesos del servidor se conecta por sí solo a una dirección pública. Versión 1.0.0, herramienta de operador único, utilizada activamente por el autor.

Ambos servidores hablan el Protocolo de Contexto de Modelos (MCP), por lo que una herramienta de IA como Claude o ChatGPT puede utilizarlos. El tráfico propio de cada servidor va únicamente a tu propio ordenador o a tu red local; una protección de arranque rechaza las direcciones públicas. Instalar las dos dependencias directas requiere internet una vez, en el momento de la configuración. Descargar un modelo es un asunto aparte: en mcp-modelmanager, llamar a fetch_model es una conexión deliberada, activada por herramienta, desde tu máquina de modelos a un registro público de modelos, en el momento en que la invoques, no algo limitado al momento de la configuración. El source="ollama" predeterminado hace que el demonio Ollama de la propia máquina descargue de registry.ollama.ai para nombres de modelo simples, o de cualquier otro registro al que apunte un nombre con prefijo como hf.co/user/repo; source="huggingface" en cambio se conecta directamente a Hugging Face. switch_service nunca se conecta a ninguno de los dos registros por sí mismo; se niega y pide fetch_model primero si el modelo no está ya en la máquina. Cada servidor es independiente: elige uno o ejecuta ambos.

Una advertencia: la herramienta de IA con la que manejas estos servidores (Claude, ChatGPT, etc.) es en el caso habitual un servicio alojado. Las instrucciones que le das y las entradas y resultados de herramientas que maneja pasan por ese proveedor, exactamente igual que cualquier otra llamada MCP. "Local" aquí significa los modelos, la máquina de modelos y sus datos; no es una afirmación de que nada de lo que escribas llegue jamás a un tercero. Maneja estos servidores con un modelo local si eso te importa.

Los dos servidores

`mcp-modelmanager` -> mcp-modelmanager/

Gestiona tu propia máquina de modelos a través de una herramienta de IA: lee el estado (memoria GPU, disco, servicio en ejecución, contenedores), descarga y elimina modelos, cambia el servicio de inferencia vLLM a un modelo diferente, crea variantes personalizadas de Ollama y ejecuta entrenamiento LoRA. Deliberadamente no hay ninguna herramienta de control remoto libre: cada operación es una plantilla fija y cada parámetro pasa primero por una lista de permitidos, verificada de forma independiente en ambos lados. Este servidor incluye ambas partes: el código cliente/servidor con el que habla la herramienta de IA, y los scripts del lado de la máquina, el envoltorio y las plantillas de red que se ejecutan y bloquean la máquina de modelos.

`mcp-ollama-vllm` -> mcp-ollama-vllm/

Llama a un modelo local directamente desde una sesión de IA para el trabajo de lenguaje: escribir, resumir, clasificar, extraer datos estructurados. Su característica distintiva es la salida JSON validada por esquema, verificada por su propio validador sin dependencias y reintentada automáticamente ante una violación, de la misma manera tanto si el backend configurado es Ollama como vLLM. Es una llamada a modelo, no un agente: sin herramientas, sin acceso a archivos, sin shell.

Los dos son complementarios. mcp-ollama-vllm pregunta a un modelo (solo lectura, sin derechos de gestión); mcp-modelmanager gestiona la máquina. Mantenerlos separados significa que una llamada de consulta nunca tenga accidentalmente derechos de gestión.

Estructura del repositorio

.
|-- README.md                 this file
|-- CHANGELOG.md              version history (Keep a Changelog style)
|-- CONTRIBUTING.md           how to contribute
|-- LICENSE                   MIT, covers the repo as a whole
|-- .gitignore
|-- .github/
|   `-- workflows/
|       `-- ci.yml            lockfile check, locked-tree tests, shell lint, advisory pip-audit
|-- mcp-modelmanager/         manage your own model machine (server + machine side)
|   |-- README.md             server and client guide (start here)
|   |-- SETUP.md              client-side step-by-step setup
|   |-- AGENT-SETUP.md        setup procedure written for an AI agent
|   |-- MACHINE.md            machine-side overview (start here for the machine)
|   |-- SETUP-MACHINE.md      gapless machine provisioning
|   |-- SECURITY.md           the three-layer security model
|   |-- LICENSE
|   |-- .gitignore            SSH-key and build patterns (kept from the server)
|   |-- requirements.txt
|   |-- pyproject.toml
|   |-- uv.lock               full resolved dependency tree, pinned
|   |-- src/mcp_modelmanager/  server package (server code and shared modules)
|   |-- setup/                machine-side setup scripts
|   |-- vm_side/              machine-side wrapper and job runners
|   `-- security/             network-fence templates (sshd, firewall, WireGuard)
`-- mcp-ollama-vllm/          call local models with schema-checked JSON
    |-- README.md             server guide (start here)
    |-- AGENT-SETUP.md        setup procedure written for an AI agent
    |-- SECURITY.md           what the bridge does and does not protect
    |-- LICENSE
    |-- requirements.txt
    |-- pyproject.toml
    |-- uv.lock               full resolved dependency tree, pinned
    `-- src/mcp_ollama_vllm/  server package (server code)

Inicio rápido

Cada servidor tiene su propia guía; comienza con el README en su carpeta.

mcp-modelmanager: lee mcp-modelmanager/README.md y sigue mcp-modelmanager/SETUP.md para el lado del cliente. Para la propia máquina de modelos, comienza desde mcp-modelmanager/MACHINE.md.
mcp-ollama-vllm: lee mcp-ollama-vllm/README.md; no tiene un SETUP.md separado (el README cubre la configuración, no hay lado de máquina ni derechos de gestión que documentar por separado), y su SECURITY.md establece los límites del puente.

mcp-modelmanager necesita Python 3.11 o superior, mcp-ollama-vllm 3.10 o superior; cada uno tiene solo dos dependencias directas, fijadas (mcp y httpx); mcp en sí mismo incorpora una serie de paquetes adicionales de forma transitiva (anyio, pydantic, starlette, uvicorn, jsonschema, pyjwt entre ellos). El árbol completo resuelto, directo y transitivo, está fijado por servidor en su uv.lock; CI verifica con uv lock --check que el bloqueo sigue coincidiendo con pyproject.toml y ejecuta las pruebas contra el árbol bloqueado exacto, por lo que un bloqueo desviado hace fallar la CI. No se requiere cuenta, ni servicio de pago, ni nube.

Instalación / Uso

Instala cualquiera de los servidores que necesites desde PyPI:

pip install mcp-modelmanager
pip install mcp-ollama-vllm

Cada uno incluye un punto de entrada de consola (mcp-modelmanager / mcp-ollama-vllm) después de la instalación, por lo que un cliente MCP puede apuntar command directamente a él, por ejemplo:

{
  "mcpServers": {
    "modelmanager": {
      "command": "/path/to/.venv/bin/mcp-modelmanager",
      "env": {
        "MM_ACCESS": "direct",
        "MM_VM_HOST": "<your-machine-or-127.0.0.1>",
        "MM_VM_USER": "<your-ssh-user>",
        "MM_CONTAINER_ROOT": "/srv/models"
      }
    },
    "local-models": {
      "command": "/path/to/.venv/bin/mcp-ollama-vllm",
      "env": {
        "LOCAL_BACKEND": "ollama",
        "LOCAL_HOST": "http://localhost:11434"
      }
    }
  }
}

Las variables de entorno requeridas difieren por servidor (mcp-modelmanager necesita los tres campos MM_* anteriores para iniciarse en absoluto; mcp-ollama-vllm se ejecuta con valores predeterminados para un Ollama local). Esto es solo la forma; no copies los valores literalmente. Para los pasos completos y actuales de instalación/registro, incluida la ruta basada en checkout (no PyPI) y la ejecución desde el código fuente, consulta el README de cada servidor: mcp-modelmanager/README.md y mcp-ollama-vllm/README.md.

Seguridad y alcance

Local y autoalojado. Ambos procesos de servidor se ejecutan en tu propio hardware y hablan solo con tu propio ordenador o tu red local/privada. Las direcciones públicas se rechazan al inicio, y los nombres se resuelven de modo que la protección no pueda eludirse mediante DNS. Esto rige el tráfico propio de los servidores; la herramienta de IA que los maneja es un servicio separado (ver la advertencia anterior), y también lo es una descarga de modelo que actives explícitamente mediante mcp-modelmanager (fetch_model): con el source="ollama" predeterminado hace que el demonio Ollama de la propia máquina descargue de registry.ollama.ai (o del registro al que apunte un nombre de modelo con prefijo como hf.co/user/repo), y con source="huggingface" se conecta directamente a Hugging Face, ambos desde la máquina de modelos en el momento en que lo solicites. switch_service no se conecta a ninguno de los dos registros; rechaza un modelo que no esté ya en la máquina y te indica fetch_model en su lugar.
Sin credenciales en este repositorio. No se almacenan claves, tokens ni contraseñas aquí; las claves SSH para mcp-modelmanager viven fuera del repositorio en tu ~/.ssh, y el .gitignore además excluye patrones de claves y .env.
Marcadores de posición, no valores reales. Cada valor específico de máquina en los documentos y plantillas es un <placeholder> o una variable de entorno que completas en tu propia máquina en el momento de la configuración.
Cada servidor tiene su propio SECURITY.md (mcp-modelmanager, mcp-ollama-vllm) que profundiza en los límites y capas de confianza reales, y establece claramente lo que queda sin abordar.