Function Calling mit Ollama

Was dieser Artikel über Function Calling behandelt

• Was Function Calling ist.
• Welche Ollama-Modelle Tool-Use unterstützen.
• JSON-Mode und Schema.
• Wie ein Tool-Call im Prompt formuliert wird.
• Praktisches Python-Beispiel.

Einleitung: Function Calling mit Ollama

Function Calling ermöglicht es Sprachmodellen, nicht nur Text zu erzeugen, sondern auch strukturierte Aufrufe für externe Funktionen auszugeben. Damit kann ein Modell beispielsweise Daten abfragen, Berechnungen anstoßen oder Aktionen in einer Anwendung auslösen. Ollama unterstützt Function Calling bei passenden Modellen, und mit dem richtigen Prompt kann ein Modell dazu gebracht werden, JSON mit Funktionsnamen und Parametern zurückzugeben.

Dieser Artikel zeigt, wie Function Calling mit Ollama funktioniert und wie man es in eigenen Skripten nutzt.

Wichtige Begriffe

• Function Calling: Modell gibt strukturierte Aufrufe aus.
• Tool Use: Synonym für Function Calling.
• JSON-Mode: Modell liefert ausschliesslich JSON.
• Schema: Definition der erlaubten Funktionen und Parameter.
• System Prompt: Anweisung, die das Modell auf Function Calling vorbereitet.
• Named Entity: Erkannte Entität, die in ein Tool-Argument überführt wird.
• Tool Result: Ergebnis, das zurück an das Modell gegeben wird.

Funktionsweise

1. Anwendung erhält Benutzeranfrage.
2. Modell wird mit verfügbaren Tools gefüttert.
3. Modell entscheidet, ob ein Tool aufgerufen wird.
4. Anwendung führt Tool aus.
5. Ergebnis wird an das Modell zurückgegeben.
6. Modell formuliert Antwort auf Basis des Tool-Ergebnisses.

Unterstützte Modelle

• Llama 3.1 und neuere Versionen mit Tool-Use.
• Qwen 2.5 und grössere Varianten.
• Mistral, Mixtral und manche Finetunes.
• Nicht jedes Modell eignet sich, da es saubere JSON-Ausgabe braucht.

System Prompt für Function Calling

Der Assistent kann Funktionen aufrufen, wenn die Anfrage es erfordert.
Antworten entweder mit normalem Text oder mit einem JSON-Objekt im folgenden Format, wenn ein Tool benötigt wird:

{
  "function": "tool_name",
  "arguments": {
    "key": "value"
  }
}

Verfügbare Tools definieren

Verfügbare Tools:
- wetter(location: str) -> str
- rechnen(ausdruck: str) -> str

Python-Beispiel

import requests
import json

url = "http://localhost:11434/api/generate"

tools = {
    "wetter": lambda location: f"Sonnig in {location}, 22 °C.",
    "rechnen": lambda ausdruck: str(eval(ausdruck))
}

system_prompt = """Der Assistent kann Funktionen aufrufen.

Wenn ein Tool nötig ist, antworte ausschliesslich mit JSON in diesem Format:
{
  "function": "tool_name",
  "arguments": {"key": "value"}
}

Verfügbare Tools:
- wetter(location: str)
- rechnen(ausdruck: str)
"""

def call_ollama(prompt, model="llama3.1"):
    response = requests.post(url, json={
        "model": model,
        "prompt": f"{system_prompt}\n\nBenutzer: {prompt}\nAssistent:",
        "format": "json",
        "stream": False
    })
    return response.json()["response"].strip()

def process(user_input):
    raw = call_ollama(user_input)
    try:
        call = json.loads(raw)
        name = call["function"]
        args = call["arguments"]
        result = tools[name](**args)

        # Zweiter Aufruf mit Tool-Ergebnis
        second = call_ollama(f"Ergebnis von {name}({args}): {result}\nBeantworte nun die ursprüngliche Frage.")
        return second
    except (json.JSONDecodeError, KeyError, TypeError):
        return raw

print(process("Wie ist das Wetter in Berlin?"))

JSON-Mode nutzen

Mit format: json zwingt Ollama das Modell, JSON auszugeben. Trotzdem muss das Modell trainiert sein, sauberes JSON zu liefern. Bei kleineren Modellen kann es helfen, das Schema anzugeben.

Schema im Prompt

{
  "function": "tool_name",
  "arguments": {
    "arg_name": "typ"
  }
}

Tool-Ergebnis zurückgeben

Das Modell braucht Kontext, um auf das Ergebnis zu antworten:

Ergebnis von wetter(location="Berlin"): "Sonnig, 22 °C."
Beantworte die Frage: Wie ist das Wetter in Berlin?

Fehlerbehandlung

• Ungültiges JSON: Erneuter Versuch mit kürzerem Prompt.
• Unbekannte Funktion: Rückmeldung an das Modell.
• Falscher Parameter-Typ: Validierung vor Tool-Aufruf.
• Kein Function Call: Direkte Textantwort anzeigen.

Sicherheit

• Niemals eval ohne Prüfung verwenden.
• Eingaben validieren, bevor Tools sie erhalten.
• Zugriff auf gefährliche Tools einschränken.
• Logs keine Secrets enthalten lassen.
• Rechte der Tool-Funktionen begrenzen.

Weiterführende Links und Infos

• BotServ.de Ollama Agenten-Workflows
• BotServ.de Ollama MCP
• BotServ.de Ollama REST API

FAQ: Function Calling mit Ollama

Welche Modelle eignen sich am besten? Llama 3.1, Qwen 2.5 und mistral-nemo sind gute Kandidaten.

Brauche ich JSON-Mode? Ja, um verlässliche Ausgaben zu erhalten.

Kann Ollama mehrere Tools auf einmal aufrufen? Theoretisch ja, aber viele Modelle geben nur einen Aufruf pro Antwort aus.

Was ist, wenn das JSON ungültig ist? Das Tool sollte einen Fehler zurückgeben und optional einen neuen Versuch anfordern.

Sollte eval genutzt werden? Nur mit extremen Einschränkungen und niemals bei Benutzereingaben.

Quellen und weiterführende Literatur

• Ollama API: https://github.com/ollama/ollama/blob/main/docs/api.md
• Function Calling Leitfaden: https://platform.openai.com/docs/guides/function-calling
• llama.cpp Grammars: https://github.com/ggerganov/llama.cpp/blob/master/grammars/README.md

Zusammenfassung: Function Calling mit Ollama

Function Calling erweitert Ollama um strukturierte Werkzeugaufrufe. Mit einem klaren System-Prompt, einer Tool-Definition, JSON-Mode und robuster Fehlerbehandnung lassen sich viele Anwendungen automatisieren. Nicht jedes Modell ist geeignet, und Sicherheit ist wichtig. Wer Function Calling einbaut, sollte Eingaben validieren, Tools einschränken und immer mit Fallback arbeiten.