Ollama-Funktionen (Function Calling)

Was dieser Artikel über Ollama-Funktionen behandelt

• Was Function Calling ist.
• Wie man Tools in Ollama definiert.
• JSON-Modus und force-output.
• Welche Modelle Funktionen unterstützen.
• Praktisches Beispiel in Python.

Einleitung: Ollama-Funktionen (Function Calling)

Function Calling ermöglicht es Sprachmodellen, bestimmte Aktionen auszulösen, indem sie strukturierte Parameter für externe Funktionen zurückgeben. Statt die Antwort selbst zu formulieren, ruft das Modell eine Werkzeug-Funktion auf, etwa um das Wetter abzufragen, eine Berechnung durchzuführen oder Daten zu suchen. In Ollama ist Function Calling begrenzt verfügbar und erfordert meist JSON-Output sowie ein Modell, das Tools versteht.

Dieser Artikel zeigt, wie Function Calling mit Ollama funktioniert.

Wichtige Begriffe

• Function Calling: Modell ruft externe Funktionen.
• Tool: Externe Funktion, die dem Modell bekannt ist.
• Schema: JSON-Schema für Funktionsparameter.
• JSON-Modus: Erzwingt validen JSON-Output.
• force: Zwingt Modell, bestimmte Funktion aufzurufen.
• OpenAI Tools: Branchenstandard für Function Calling.
• Ollama tools: Ollama-spezifische Implementierung.
• Stop/Start: Steuerzeichen für JSON.

Unterstützung in Ollama

Function Calling in Ollama ist noch jünger und weniger umfassend als bei OpenAI. Einige Modelle wie Qwen 2.5, Llama 3.1 und einige Mistral-Varianten können Tools nutzen. Die API entspricht dem OpenAI-Tool-Format.

Tool definieren

{
  "tools": [
    {
      "type": "function",
      "function": {
        "name": "get_weather",
        "description": "Liefert das aktuelle Wetter für einen Ort.",
        "parameters": {
          "type": "object",
          "properties": {
            "location": {
              "type": "string",
              "description": "Stadt oder Ort"
            },
            "unit": {
              "type": "string",
              "enum": ["celsius", "fahrenheit"]
            }
          },
          "required": ["location"]
        }
      }
    }
  ]
}

Python-Beispiel

import requests

url = "http://localhost:11434/api/chat"
payload = {
    "model": "qwen2.5:7b",
    "messages": [
        {"role": "user", "content": "Wie ist das Wetter in Berlin?"}
    ],
    "tools": [
        {
            "type": "function",
            "function": {
                "name": "get_weather",
                "description": "Liefert das aktuelle Wetter.",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "location": {"type": "string"},
                        "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]}
                    },
                    "required": ["location"]
                }
            }
        }
    ],
    "stream": False
}

response = requests.post(url, json=payload)
print(response.json())

Ergebnis auswerten

Das Modell antwortet mit einer tool_calls-Struktur:

{
  "message": {
    "role": "assistant",
    "tool_calls": [
      {
        "function": {
          "name": "get_weather",
          "arguments": {"location": "Berlin", "unit": "celsius"}
        }
      }
    ]
  }
}

Funktion ausführen

Die Anwendung führt die Funktion aus und fügt das Ergebnis dem Chatverlauf hinzu:

tool_result = get_weather("Berlin", "celsius")

payload["messages"].append({
    "role": "tool",
    "content": tool_result,
    "name": "get_weather"
})

response = requests.post(url, json=payload)
print(response.json()["message"]["content"])

JSON-Modus erzwingen

{
  "format": "json"
}

Das hilft, wenn das Modell sonst Markdown-Blöcke um den JSON-Output legt.

Ollama-Modelfile mit Tools

FROM qwen2.5:7b

PARAMETER temperature 0.1
SYSTEM "Du bist ein Helfer, der Werkzeuge nutzt, um Aufgaben zu erledigen."

Nicht alle Parameter direkt definieren Tools, sie werden über API übergeben.

Tipps

• Modell wählen, das Tools unterstützt.
• Schemas klar und einfach halten.
• Tool-Namen verständlich wählen.
• Antworten immer validieren.
• Fehler abfangen, falls Modell halluziniert.
• Wenige Tools pro Anfrage nutzen.
• Parameter-Typen festlegen.

Typische Stolpersteine

• Modell unterstützt keine Tools: Kleine oder alte Modelle ignorieren Tools.
• Keine Tool-Ausgabe: Modell antwortet normal statt zu callen.
• JSON-Fehler: Output muss geparst werden.
• Falsche Parameter: Schema ist zu komplex.
• Mehrfache Tool-Calls: Anwendung muss mehrere Calls abarbeiten.
• CORS/Netzwerk: Client kann API nicht erreichen.

Weiterführende Links und Infos

• BotServ.de Ollama Modell-Galerie
• BotServ.de Ollama API-Fehlerbehebung
• BotServ.de Ollama in Docker
• BotServ.de KI-Agenten Frameworks

FAQ: Ollama-Funktionen

Welche Modelle unterstützen Function Calling? Qwen 2.5, Llama 3.1 und einige Mistral-Varianten.

Muss ich Tools im Modelfile definieren? Nein, sie werden über die API übergeben.

Kann ich mehrere Tools gleichzeitig nutzen? Ja, je nach Modell und Anfrage.

Wie erzwinge ich JSON-Output? Mit "format": "json".

Funktioniert Function Calling bei allen Modellen? Nein, nur bei Modellen, die darauf trainiert wurden.

Quellen und weiterführende Literatur

• Ollama Tools: https://ollama.com/blog/tool-support
• OpenAI Function Calling: https://platform.openai.com/docs/guides/function-calling

Zusammenfassung: Ollama-Funktionen (Function Calling)

Function Calling ermöglicht Ollama-Modellen, externe Werkzeuge aufzurufen. Tools werden als JSON-Schemas definiert und über die API übergeben. Modelle wie Qwen 2.5 und Llama 3.1 unterstützen diesen Modus. Die Anwendung muss die Tool-Aufrufe entgegennehmen, die Funktionen ausführen und Ergebnisse zurückgeben. Mit klaren Schemas, JSON-Output und Validierung lassen sich Agenten-Workflows auch lokal realisieren.