Local AI MCP Servers

Dois servidores MCP auto-hospedados: gerencie uma máquina de modelo local (pull/switch do Ollama, treinamento de LoRA) e faça a ponte para Ollama/vLLM local em tarefas de linguagem.

GitHubExperimente este MCPPatrocinado

Documentação

Servidores MCP de IA Local: gerenciamento de modelos Ollama & vLLM e acesso a LLM local para Claude, ChatGPT e outros clientes MCP

Dois servidores auto-hospedáveis do Model Context Protocol (MCP) para executar e controlar seus próprios modelos de linguagem locais: gerencie uma máquina de modelos Ollama/vLLM e consulte um LLM local (Ollama, vLLM ou um backend compatível com OpenAI) para trabalhos de linguagem com saída JSON validada por esquema. Auto-hospedado e priorizando a privacidade: os modelos e sua máquina permanecem no seu próprio hardware, e nenhum processo do servidor acessa um endereço público por conta própria. Versão 1.0.0, ferramenta de operador único, usada ativamente pelo autor.

Ambos os servidores falam o Model Context Protocol (MCP), para que uma ferramenta de IA como Claude ou ChatGPT possa usá-los. O tráfego de cada servidor vai apenas para o seu próprio computador ou sua rede local; uma proteção de inicialização rejeita endereços públicos. Instalar as duas dependências diretas exige internet uma vez, no momento da configuração. Baixar um modelo é uma questão separada: em mcp-modelmanager, chamar fetch_model é uma conexão deliberada, acionada por ferramenta, da sua máquina de modelos a um registro público de modelos, no momento em que você a invoca, não algo limitado ao momento de configuração. O source="ollama" padrão faz o daemon Ollama da própria máquina baixar de registry.ollama.ai para nomes de modelos simples, ou de qualquer outro registro para o qual um nome prefixado como hf.co/user/repo aponte; source="huggingface" em vez disso acessa o Hugging Face diretamente. switch_service nunca acessa nenhum dos registros por conta própria; ele recusa e pede fetch_model primeiro se o modelo ainda não estiver na máquina. Cada servidor é independente: escolha um ou execute ambos.

Uma ressalva: a ferramenta de IA com a qual você dirige esses servidores (Claude, ChatGPT, etc.) é, no caso usual, um serviço hospedado. As instruções que você dá a ela e as entradas e saídas de ferramentas que ela manipula passam por esse provedor, exatamente como qualquer outra chamada MCP. "Local" aqui significa os modelos, a máquina de modelos e seus dados; não é uma afirmação de que nada que você digita chega a terceiros. Use um modelo local para dirigi-los se isso for importante para você.

Os dois servidores

`mcp-modelmanager` -> mcp-modelmanager/

Gerencie sua própria máquina de modelos por meio de uma ferramenta de IA: leia o estado (memória GPU, disco, serviço em execução, contêineres), baixe e remova modelos, alterne o serviço de inferência vLLM para um modelo diferente, crie variantes Ollama personalizadas e execute treinamento LoRA. Não há deliberadamente nenhuma ferramenta para controle remoto livre: cada operação é um modelo fixo e cada parâmetro passa primeiro por uma lista de permissões, verificada de forma independente em ambos os lados. Este servidor entrega ambas as partes: o código cliente/servidor com o qual a ferramenta de IA fala, e os scripts do lado da máquina, wrapper e modelos de rede que executam e bloqueiam a máquina de modelos.

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

Chame um modelo local diretamente de uma sessão de IA para o trabalho de linguagem: escrever, resumir, classificar, extrair dados estruturados. Sua característica distintiva é a saída JSON validada por esquema, verificada por seu próprio validador sem dependências e repetida automaticamente em caso de violação, da mesma forma, quer o backend configurado seja Ollama ou vLLM. É uma chamada de modelo, não um agente: sem ferramentas, sem acesso a arquivos, sem shell.

Os dois são complementares. mcp-ollama-vllm pergunta a um modelo (somente leitura, sem direitos de gerenciamento); mcp-modelmanager gerencia a máquina. Mantê-los separados significa que uma chamada de consulta nunca detém acidentalmente direitos de gerenciamento.

Estrutura do repositório

.
|-- 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)

Início rápido

Cada servidor tem seu próprio guia; comece com o README em sua pasta.

mcp-modelmanager: leia mcp-modelmanager/README.md e siga mcp-modelmanager/SETUP.md para o lado do cliente. Para a própria máquina de modelos, comece por mcp-modelmanager/MACHINE.md.
mcp-ollama-vllm: leia mcp-ollama-vllm/README.md; ele não tem um SETUP.md separado (o README cobre a configuração, não há lado de máquina e nenhum direito de gerenciamento para documentar separadamente), e seu SECURITY.md declara os limites da ponte.

mcp-modelmanager precisa de Python 3.11 ou mais recente, mcp-ollama-vllm 3.10 ou mais recente; cada um tem apenas duas dependências diretas e fixadas (mcp e httpx); mcp em si atrai uma série de outros pacotes transitivamente (anyio, pydantic, starlette, uvicorn, jsonschema, pyjwt entre eles). A árvore completa resolvida, direta e transitiva, é fixada por servidor em seu uv.lock; o CI verifica com uv lock --check se o lock ainda corresponde a pyproject.toml e executa os testes contra a árvore exatamente bloqueada, então um lock desatualizado falha no CI. Nenhuma conta, nenhum serviço pago, nenhuma nuvem é necessária.

Instalação / Uso

Instale o(s) servidor(es) que você precisar do PyPI:

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

Cada um entrega um ponto de entrada de console (mcp-modelmanager / mcp-ollama-vllm) após a instalação, para que um cliente MCP possa apontar command diretamente para ele, por exemplo:

{
  "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"
      }
    }
  }
}

As variáveis de ambiente necessárias diferem por servidor (mcp-modelmanager precisa dos três campos MM_* acima para iniciar; mcp-ollama-vllm executa com padrões para um Ollama local). Isto é apenas a forma; não copie os valores literalmente. Para as etapas completas e atuais de instalação/registro, incluindo o caminho baseado em checkout (não-PyPI) e a execução a partir do código-fonte, veja o README de cada servidor: mcp-modelmanager/README.md e mcp-ollama-vllm/README.md.

Segurança e escopo

Local e auto-hospedado. Ambos os processos do servidor executam no seu próprio hardware e falam apenas com o seu próprio computador ou sua rede local/privada. Endereços públicos são rejeitados na inicialização, e os nomes são resolvidos para que a proteção não possa ser contornada via DNS. Isso rege o tráfego próprio dos servidores; a ferramenta de IA que os dirige é um serviço separado (veja a ressalva acima), e também é um download de modelo que você aciona explicitamente por meio de mcp-modelmanager (fetch_model): com o source="ollama" padrão, ele faz o daemon Ollama da própria máquina baixar de registry.ollama.ai (ou do registro para o qual um nome de modelo prefixado como hf.co/user/repo aponte), e com source="huggingface" ele acessa o Hugging Face diretamente, ambos a partir da máquina de modelos no momento em que você o solicita. switch_service não acessa nenhum dos registros; ele recusa um modelo que já não esteja na máquina e aponta você para fetch_model em vez disso.
Sem credenciais neste repositório. Nenhuma chave, token ou senha é armazenada aqui; chaves SSH para mcp-modelmanager ficam fora do repositório no seu ~/.ssh, e o .gitignore adicionalmente exclui padrões de chave e .env.
Espaços reservados, não valores reais. Cada valor específico de máquina nos documentos e modelos é um <placeholder> ou uma variável de ambiente que você preenche na sua própria máquina no momento da configuração.
Cada servidor tem seu próprio SECURITY.md (mcp-modelmanager, mcp-ollama-vllm) que aborda as fronteiras e camadas de confiança reais e declara claramente o que permanece não resolvido.