Ollama mit MCP-Servern verbinden: Werkzeuge für lokale Modelle

Ollama führt Sprachmodelle lokal aus, kennt von Haus aus aber keine externen Werkzeuge. Das Model Context Protocol (MCP) schließt diese Lücke: Ein MCP-Server stellt Dateizugriff, Datenbankabfragen oder HTTP-Requests als standardisierte Tools bereit. In dieser Anleitung verbindest du beide Seiten, einmal mit dem fertigen Client mcphost und einmal mit einer eigenen Python-Bridge.

Was ist MCP und warum braucht Ollama einen Host?

Das Model Context Protocol ist ein offener JSON-RPC-Standard, über den ein Client Werkzeuge, Ressourcen und Prompts von einem Server abruft; Ollama implementiert dieses Protokoll nicht selbst und benötigt deshalb einen Host-Prozess als Vermittler.

Die Aufgabenteilung ist klar geschnitten. Der MCP-Server kennt die Werkzeuge und führt sie aus. Ollama liefert das Modell und entscheidet, welches Werkzeug mit welchen Argumenten aufgerufen werden soll. Dazwischen sitzt der Host: Er holt per tools/list die Schemas vom Server, übersetzt sie in das Function-Calling-Format der Ollama-API, reicht die Antwort des Modells als tools/call an den Server weiter und schiebt das Ergebnis als Nachricht mit role: tool zurück in den Dialog.

graph TD
    A["Prompt des Nutzers"] --> B["Host / Bridge"]
    B -->|"tools/list"| C["MCP-Server (stdio)"]
    C -->|"Tool-Schemas"| B
    B -->|"POST /api/chat mit tools"| D["Ollama"]
    D -->|"tool_calls"| B
    B -->|"tools/call"| C
    C -->|"Tool-Ergebnis"| B
    B -->|"Nachricht mit role: tool"| D
    D -->|"finale Antwort"| A

MCP-Server sprechen zwei Transporte: stdio, bei dem der Host den Serverprozess selbst startet, und Streamable HTTP für entfernte Server. Für lokale Werkzeuge ist stdio der Normalfall und der Ausgangspunkt dieser Anleitung.

Voraussetzungen

• Ein Linux-Host mit installiertem Ollama ab Version 0.4 (ollama --version)
• Node.js 20 oder neuer, damit npx die Referenz-MCP-Server ausführen kann
• Python 3.10 oder neuer für die eigene Bridge
• Mindestens 8 GB freier RAM für ein 7B- oder 8B-Modell in Q4-Quantisierung

Ollama läuft standardmäßig auf 127.0.0.1:11434. Wenn du die Umgebung auf einer skalierbaren Linux-VM betreibst, setze OLLAMA_HOST=0.0.0.0 nur zusammen mit einer Firewall-Regel: Die API kennt keine Authentifizierung.

Welche Ollama-Modelle unterstützen Tool-Calls?

Tool-Calls unterstützen in Ollama nur Modelle, deren Chat-Template einen tools-Block enthält, darunter qwen3, llama3.1, llama3.2, mistral-nemo und firefunction-v2; alle anderen Modelle quittieren Tool-Anfragen mit einem Fehler.

Ob ein Modell Tools kann, zeigt sein Template direkt:

$ ollama pull qwen3:8b
$ ollama show qwen3:8b --template | grep -c tools

Ein Wert größer als 0 bedeutet, dass das Template Tool-Definitionen verarbeitet. Bei einem Modell ohne Unterstützung antwortet die API mit does not support tools.

Die Qualität der Tool-Auswahl hängt stark an der Modellgröße. Ein 8B-Modell wählt einfache Werkzeuge zuverlässig, verhaspelt sich aber bei zehn oder mehr Tools mit ähnlichen Beschreibungen. Wenn du größere Modelle wie qwen3:32b mit akzeptabler Latenz betreiben willst, brauchst du VRAM statt CPU-Kernen. Dafür eignen sich GPU-Instanzen für lokale LLM-Inference, auf denen das Modell vollständig in den Grafikspeicher passt.

MCP-Server mit mcphost anbinden

Der Client mcphost ist ein fertiger MCP-Host in Go, der Ollama direkt als Backend ansprechen kann und Handshake, Tool-Übersetzung und Ausführungsschleife übernimmt.

$ go install github.com/mark3labs/mcphost@latest
$ export PATH=$PATH:$(go env GOPATH)/bin
$ mcphost --help

Die Serverliste liegt in einer Konfigurationsdatei im Home-Verzeichnis. Je nach Version heißt sie ~/.mcphost.yml oder ~/.mcphost.json; mcphost --help nennt den erwarteten Pfad. Das JSON-Format entspricht dem üblichen mcpServers-Block:

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/srv/daten"]
    },
    "sqlite": {
      "command": "uvx",
      "args": ["mcp-server-sqlite", "--db-path", "/srv/daten/metrics.db"]
    }
  }
}

Der Pfad /srv/daten ist die Wurzel, auf die der Filesystem-Server beschränkt bleibt. Gib hier nie / an: Das Modell erhält sonst Lese- und Schreibzugriff auf das gesamte Dateisystem.

Starte die Sitzung mit einem tool-fähigen Modell:

$ mcphost -m ollama:qwen3:8b

Innerhalb der Sitzung listet /tools alle geladenen Werkzeuge auf. Läuft Ollama auf einem anderen Host, setze vorher export OLLAMA_HOST=http://<dein-host>:11434.

Eigene Bridge in Python bauen

Für eigene Anwendungen kombinierst du das offizielle MCP-Python-SDK mit dem Ollama-Client. Die einzige echte Arbeit ist die Übersetzung der Tool-Schemas: MCP liefert name, description und inputSchema, Ollama erwartet ein Objekt mit type: function und parameters.

$ python3 -m venv ~/.venvs/mcp-bridge
$ source ~/.venvs/mcp-bridge/bin/activate
$ pip install "mcp>=1.2" "ollama>=0.4"

Lege die Bridge unter /opt/mcp-bridge/bridge.py ab:

import asyncio
from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client
from ollama import AsyncClient
MODEL = "qwen3:8b"
SERVER = StdioServerParameters(
    command="npx",
    args=["-y", "@modelcontextprotocol/server-filesystem", "/srv/daten"],
)
def to_ollama_tool(tool):
    return {
        "type": "function",
        "function": {
            "name": tool.name,
            "description": tool.description or "",
            "parameters": tool.inputSchema,
        },
    }
async def run(prompt):
    async with stdio_client(SERVER) as (read, write):
        async with ClientSession(read, write) as session:
            await session.initialize()
            listed = await session.list_tools()
            tools = [to_ollama_tool(t) for t in listed.tools]
            messages = [{"role": "user", "content": prompt}]
            client = AsyncClient()
            for _ in range(5):
                reply = await client.chat(
                    model=MODEL,
                    messages=messages,
                    tools=tools,
                    options={"num_ctx": 8192},
                )
                message = reply["message"]
                messages.append(message)
                calls = message.get("tool_calls") or []
                if not calls:
                    print(message["content"])
                    return
                for call in calls:
                    name = call["function"]["name"]
                    args = call["function"]["arguments"]
                    print(f"[tool] {name} {args}")
                    result = await session.call_tool(name, args)
                    text = "".join(
                        block.text for block in result.content
                        if block.type == "text"
                    )
                    messages.append(
                        {"role": "tool", "name": name, "content": text}
                    )
asyncio.run(run("Welche Dateien liegen in /srv/daten? Fasse den Inhalt kurz zusammen."))

Drei Details entscheiden über die Stabilität:

• await session.initialize() muss vor jedem Aufruf laufen, sonst lehnt der Server tools/list ab.
• Die Schleifenbegrenzung (for _ in range(5)) verhindert, dass ein Modell endlos Werkzeuge aufruft.
• options={"num_ctx": 8192} hebt das Kontextfenster an. Viele Modelle laufen in Ollama standardmäßig mit 4096 Token, und die Tool-Schemas belegen davon bereits einen spürbaren Anteil.

Starte die Bridge:

$ python3 /opt/mcp-bridge/bridge.py

Verifikation

Prüfe die Kette in zwei Stufen. Zuerst der reine Tool-Call von Ollama, ohne MCP im Spiel:

$ curl -s http://localhost:11434/api/chat -d '{"model":"qwen3:8b","stream":false,"messages":[{"role":"user","content":"Wie ist das Wetter in Berlin?"}],"tools":[{"type":"function","function":{"name":"get_weather","description":"Wetter für eine Stadt abfragen","parameters":{"type":"object","properties":{"city":{"type":"string"}},"required":["city"]}}}]}' | jq '.message.tool_calls'

Erwarteter Output:

[
  {
    "function": {
      "name": "get_weather",
      "arguments": {
        "city": "Berlin"
      }
    }
  }
]

Kommt hier null zurück, liegt das Problem beim Modell, nicht bei MCP. Erst danach prüfst du den kompletten Durchlauf: Die Bridge gibt bei jedem Werkzeugaufruf eine [tool]-Zeile aus, gefolgt von der Antwort des Modells.

Den MCP-Server allein testest du mit dem Inspector, der die Werkzeugliste im Browser anzeigt:

$ npx -y @modelcontextprotocol/inspector npx -y @modelcontextprotocol/server-filesystem /srv/daten

Troubleshooting

registry.ollama.ai/library/<modell> does not support tools Das gewählte Modell hat kein Tool-Template. Wechsle auf qwen3, llama3.1 oder mistral-nemo und prüfe mit ollama show <modell> --template.

Das Modell ignoriert die Werkzeuge Meistens ist das Kontextfenster zu klein und die Tool-Definitionen fallen aus dem Prompt. Setze num_ctx auf mindestens 8192 und reduziere die Anzahl der geladenen Server. Mehr als acht bis zehn Werkzeuge gleichzeitig überfordern kleine Modelle.

Die Bridge hängt beim Start ohne Ausgabe Der stdio-Transport blockiert, wenn der Serverprozess nicht startet. Führe den Befehl aus der Konfiguration einzeln aus, etwa npx -y @modelcontextprotocol/server-filesystem /srv/daten. Fehlt Node.js oder ist der Pfad nicht vorhanden, siehst du die Ursache dort im Klartext.

ValidationError beim Tool-Aufruf Einige Modelle liefern Argumente als JSON-String statt als Objekt. Fange das ab, indem du args vor session.call_tool mit json.loads konvertierst, falls es vom Typ str ist.

Fazit

Ollama und MCP lassen sich mit wenig Code koppeln, weil der Host lediglich Schemas übersetzt und Ergebnisse zurückreicht. Für den Einstieg reicht mcphost, für eigene Anwendungen sind die rund 40 Zeilen Python die flexiblere Basis. Achte bei jedem zusätzlichen Server auf den Berechtigungsumfang: Ein Filesystem-Server mit zu weit gefasstem Wurzelpfad gibt dem Modell Schreibrechte, die du nicht mehr einzeln kontrollierst.

Weiterlesen

• Lokales Coding-Modell mit Ollama in der IDE nutzen
• Die Ollama-API aus eigenen Anwendungen ansprechen
• Ollama auf Ubuntu 24.04 installieren und als Dienst betreiben
• Ollama im Docker-Container betreiben
• Ollama im Netzwerk freigeben: Port, Bind-Adresse und Absicherung
• Ollama, LM Studio oder llama.cpp: Welches Werkzeug wofür?
• Ollama-Modelle verwalten: aktualisieren, aufräumen, Speicher sparen
• Open WebUI als Oberfläche für Ollama einrichten
• Was ist Ollama? Funktionsweise, Modelle und Einsatzgebiete