MCP mit Ollama nutzen

Was dieser Artikel über MCP und Ollama behandelt

• Was das Model Context Protocol ist.
• Wie Tools und Kontext über MCP bereitgestellt werden.
• Wie Ollama mit MCP-ähnlichen Workflows genutzt werden kann.
• Beispiele für Tools, System-Prompts und Funktionsaufrufe.
• Tipps für lokale Implementierungen.

Einleitung: MCP mit Ollama nutzen

MCP steht für Model Context Protocol. Es ist ein offener Standard, mit dem Sprachmodelle externe Tools, Datenquellen und Kontexte strukturiert nutzen können. Statt alles im Prompt unterzubringen, können Modelle gezielt Funktionen aufrufen, Ergebnisse verarbeiten und so komplexere Aufgaben lösen. Mit Ollama lässt sich ein ähnliches Verhalten aufbauen, indem man Tools in die API-Anfrage einbettet und die Antworten des Modells interpretiert.

Dieser Artikel zeigt die Idee hinter MCP, wie Tools definiert werden und wie man ein einfaches Beispiel mit Ollama umsetzt.

Wichtige Begriffe

• MCP: Model Context Protocol.
• Tool: Externe Funktion, die das Modell aufrufen kann.
• Function Calling: Modell entscheidet, welche Funktion es aufrufen möchte.
• Schema: Beschreibung einer Funktion und ihrer Parameter.
• Context: Zusätzliche Informationen, die dem Modell zur Verfügung gestellt werden.
• Agent: System, das Modell, Tools und Logik kombiniert.
• Server: Komponente, die Tools bereitstellt.
• Client: Anwendung, die Anfragen an den MCP-Server und das Modell sendet.

Wozu dient MCP?

MCP hilft dabei:

• Modelle mit aktuellen Daten zu versorgen.
• Auf lokale Dateien, Datenbanken oder APIs zuzugreifen.
• Berechnungen oder Aktionen auszuführen.
• Wiederkehrende Aufgaben zu automatisieren.
• Mehrstufige Workflows zu ermöglichen.

Statt ein Modell alles auswendig zu lernen, holt es sich bei Bedarf Informationen aus der Umgebung.

Tools definieren

Ein Tool wird durch ein JSON-Schema beschrieben. Beispiel für eine Wetterfunktion:

{
  "type": "function",
  "function": {
    "name": "get_weather",
    "description": "Gibt das aktuelle Wetter für einen Ort zurück.",
    "parameters": {
      "type": "object",
      "properties": {
        "location": {
          "type": "string",
          "description": "Stadt oder Ort"
        }
      },
      "required": ["location"]
    }
  }
}

Ollama und Function Calling

Ollama selbst bietet keinen nativen MCP-Server, unterstützt aber das Einbinden von Tools über das Chat-Format. Das Modell liefert bei bestimmten Modellen ein spezielles Antwortformat, das man als Function Call interpretieren kann.

Beispiel mit Python

import ollama
import json

weather_schema = {
    "name": "get_weather",
    "description": "Gibt das aktuelle Wetter für einen Ort zurück.",
    "parameters": {
        "type": "object",
        "properties": {
            "location": {"type": "string"}
        },
        "required": ["location"]
    }
}

def get_weather(location):
    return f"Das Wetter in {location} ist sonnig und 22 Grad."

messages = [
    {"role": "user", "content": "Wie ist das Wetter in Berlin?"}
]

response = ollama.chat(
    model="qwen2.5:14b",
    messages=messages,
    tools=[weather_schema]
)

print(response["message"]["content"])

Wenn das Modell den Tool-Aufruf in seiner Antwort kodiert, kann die Anwendung die Funktion ausführen und das Ergebnis zurücksenden.

Zwei-Schritt-Workflow

import re

answer = response["message"]["content"]
match = re.search(r"get_weather\(.*location=[\"'](.+?)[\"']\)", answer)

if match:
    location = match.group(1)
    result = get_weather(location)

    messages.append({"role": "assistant", "content": answer})
    messages.append({"role": "tool", "content": result})

    final = ollama.chat(model="qwen2.5:14b", messages=messages)
    print(final["message"]["content"])

Wichtig: Das Format des Tool-Aufrufs hängt vom Modell ab. Spezialisierte Tool-Modelle liefern strukturiertere Antworten.

MCP-Server bauen

Ein MCP-Server stellt Tools bereit und kommuniziert über ein standardisiertes Protokoll. Für Ollama kann man einen einfachen Python-Server schreiben, der über HTTP JSON-Schemas und Ergebnisse austauscht:

from fastapi import FastAPI

app = FastAPI()

@app.get("/tools")
def tools():
    return [weather_schema]

@app.post("/call")
def call(payload: dict):
    if payload["name"] == "get_weather":
        return get_weather(payload["args"]["location"])

Praktische Anwendungen

• RAG: Modell ruft passende Dokumentenabschnitte ab.
• Dateisuche: Modell sucht in einem Verzeichnis.
• Kalender: Modell liest oder schreibt Termine.
• Systeminformationen: Modell fragt CPU- oder RAM-Auslastung ab.
• API-Zugriff: Modell holt sich Daten aus lokalen oder externen APIs.

Tipps

• Klare Schemas mit guten Beschreibungen verwenden.
• Wenige, präzise Tools bieten bessere Ergebnisse als viele schlecht dokumentierte.
• Tool-Aufrufe validieren, bevor sie ausgeführt werden.
• Sicherheit beachten: Niemals ungeprüfte Befehle ausführen.
• Fehlerfälle abfangen und dem Modell als Kontext zurückgeben.
• Logs führen, um Workflows nachvollziehen zu können.

Typische Stolpersteine

• Modell unterstützt kein Function Calling: Ausgabe ist nicht strukturiert.
• Falsches Format: Modell erfindet eigene Funktionssyntax.
• Zu viele Tools: Modell wird überfordert.
• Fehlende Beschreibung: Modell wählt falsches Tool.
• Sicherheitslücken: Tool führt beliebige Befehle aus.
• Zirkuläre Aufrufe: Modell ruft Tools endlos auf.
• Fehlende Timeout-Logik: Externe Calls blockieren den Workflow.

Weiterführende Links und Infos

• BotServ.de Ollama API-Bibliotheken
• BotServ.de Ollama für Coding
• BotServ.de RAG mit Ollama
• BotServ.de Agenten-Speicher

FAQ: MCP mit Ollama

Unterstützt Ollama MCP nativ? Nicht als Server, aber Tools können über das Chat-Format eingebunden werden.

Welche Modelle eignen sich für Function Calling? qwen2.5, mistral und speziell trainierte Tool-Modelle liefern oft brauchbare Ergebnisse.

Brauche ich einen MCP-Server? Nur, wenn mehrere Anwendungen die gleichen Tools nutzen sollen. Ein simpler Python-Loop reicht oft.

Ist MCP sicher? Das Protokoll ist so sicher wie die implementierten Tools. Eingaben immer validieren.

Kann ich MCP mit Open WebUI nutzen? Open WebUI bietet eigene Tool-Funktionen. Eine direkte MCP-Integration kann je nach Version variieren.

Quellen und weiterführende Literatur

• MCP Spec: https://modelcontextprotocol.io/
• Ollama API: https://github.com/ollama/ollama/blob/main/docs/api.md
• LangChain Tools: https://python.langchain.com/docs/modules/agents/tools/

Zusammenfassung: MCP mit Ollama nutzen

MCP erweitert lokale Sprachmodelle um Tools, Datenquellen und dynamischen Kontext. Ollama ermöglicht ähnliche Workflows durch Function-Calling-ähnliche Prompts und die Interpretation der Modellantworten. Wer klare Schemas, eine sichere Ausführungslogik und einen durchdachten Zwei-Schritt-Workflow implementiert, kann aus Ollama einen datenschutzfreundlichen Agenten mit Tool-Zugriff machen. Besonders interessant ist die Kombination mit RAG, APIs und lokalen Systemdaten.