Du möchtest, dass KI-Anwendungen wie ein Assistent für dich arbeiten und echte Aufgaben erledigen? Dann bist du hier genau richtig. In diesem Guide zeige ich dir Schritt für Schritt, wie du Funktionsaufrufe (Function Calling) nutzt – die Technik, mit der KI-Modelle externe Werkzeuge steuern können.

Was sind Funktionsaufrufe und warum sind sie nützlich?

Stell dir vor, du fragst eine KI: „Wie ist das Wetter morgen in München?" Eine normale KI würde dir eine generische Antwort geben. Aber mit Funktionsaufrufen kann die KI:

Als ich vor zwei Jahren zum ersten Mal mit Function Calling arbeitete, war ich überrascht, wie einfach das Konzept ist. Die KI versteht deine Anfrage und entscheidet selbstständig, welches Werkzeug sie benötigt.

Voraussetzungen: Dein Setup

Bevor wir starten, brauchst du:

Hinweis für Screenshots: Öffne nach jedem Schritt die Konsole/Terminal, um die Ausgabe zu sehen.

Schritt 1: Python-Umgebung einrichten

Installiere das benötigte Paket mit diesem Befehl in deinem Terminal:

pip install openai httpx

Dann erstelle eine neue Datei namens function_calling_demo.py und füge diesen Code ein:

import httpx
import json


Deine Zugangsdaten von HolySheep AI

API_KEY = "YOUR_HOLYSHEEP_API_KEY"
BASE_URL = "https://api.holysheep.ai/v1"


Definiere die verfügbaren Werkzeuge (Functions)

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Ermittelt das aktuelle Wetter für einen bestimmten Ort",
            "parameters": {
                "type": "object",
                "properties": {
                    "ort": {
                        "type": "string",
                        "description": "Der Stadtname, z.B. 'München' oder 'Berlin'"
                    },
                    "einheit": {
                        "type": "string", 
                        "enum": ["celsius", "fahrenheit"],
                        "description": "Temperatureinheit, Standard ist celsius"
                    }
                },
                "required": ["ort"]
            }
        }
    },
    {
        "type": "function", 
        "function": {
            "name": "rechner",
            "description": "Führt mathematische Berechnungen durch",
            "parameters": {
                "type": "object",
                "properties": {
                    "ausdruck": {
                        "type": "string",
                        "description": "Der mathematische Ausdruck, z.B. '25 * 17 + 130'"
                    }
                },
                "required": ["ausdruck"]
            }
        }
    }
]


Sende eine Anfrage mit Funktionsaufruf-Optionen

nachricht = {
    "role": "user",
    "content": "Berechne: Was ergibt 25 mal 17 plus 130? Und wie ist das Wetter in München?"
}

response = httpx.post(
    f"{BASE_URL}/chat/completions",
    headers={
        "Authorization": f"Bearer {API_KEY}",
        "Content-Type": "application/json"
    },
    json={
        "model": "gpt-4o",
        "messages": [nachricht],
        "tools": tools
    },
    timeout=30.0
)

print("Roh-Antwort der KI:")
print(json.dumps(response.json(), indent=2, ensure_ascii=False))

Schritt 2: Das Ergebnis verstehen

Wenn du den Code ausführst, wirst du eine Antwort erhalten, die ungefähr so aussieht:

{
  "id": "chatcmpl-xxx",
  "choices": [{
    "message": {
      "role": "assistant",
      "content": null,
      "tool_calls": [
        {
          "id": "call_123",
          "type": "function",
          "function": {
            "name": "rechner",
            "arguments": "{\"ausdruck\": \"25 * 17 + 130\"}"
          }
        },
        {
          "id": "call_456", 
          "type": "function",
          "function": {
            "name": "get_weather",
            "arguments": "{\"ort\": \"München\", \"einheit\": \"celsius\"}"
          }
        }
      ]
    }
  }]
}

Screenshot-Hinweis: Achte auf den Abschnitt tool_calls – das ist das Herzstück des Funktionsaufrufs. Die KI hat erkannt, dass zwei Werkzeuge benötigt werden.

Schritt 3: Werkzeuge tatsächlich ausführen

Jetzt kommt der spannende Teil: Wir führen die aufgerufenen Funktionen wirklich aus!

# Simulierte Funktionen (in echtem Code würdest du hier echte APIs aufrufen)
def get_weather(ort, einheit="celsius"):
    """Simuliert einen Wetter-API-Aufruf"""
    wetter_daten = {
        "München": {"temperatur": 18, "bedingung": "Sonnig"},
        "Berlin": {"temperatur": 15, "bedingung": "Wolkig"},
        "Hamburg": {"temperatur": 14, "bedingung": "Leichter Regen"}
    }
    return wetter_daten.get(ort, {"temperatur": 20, "bedingung": "Unbekannt"})

def rechner(ausdruck):
    """Führt Berechnungen sicher aus"""
    try:
        # Eval nur für Demo - niemals mit Benutzereingaben in Produktion!
        ergebnis = eval(ausdruck)
        return {"ergebnis": ergebnis, "erfolgreich": True}
    except Exception as e:
        return {"ergebnis": None, "fehler": str(e), "erfolgreich": False}


Verarbeite die Funktionsaufrufe der KI

tool_ergebnisse = []

for aufruf in tool_calls:
    func_name = aufruf["function"]["name"]
    args = json.loads(aufruf["function"]["arguments"])
    aufruf_id = aufruf["id"]
    
    if func_name == "get_weather":
        ergebnis = get_weather(**args)
    elif func_name == "rechner":
        ergebnis = rechner(**args)
    else:
        ergebnis = {"fehler": f"Unbekannte Funktion: {func_name}"}
    
    tool_ergebnisse.append({
        "tool_call_id": aufruf_id,
        "role": "tool",
        "content": json.dumps(ergebnis)
    })


Sende die Ergebnisse zurück an die KI

nachrichten = [
    {"role": "user", "content": "Berechne: Was ergibt 25 mal 17 plus 130?"},
    {"role": "assistant", "content": None, "tool_calls": tool_calls},
    {"role": "tool", "tool_call_id": tool_calls[0]["id"], 
     "content": json.dumps(rechner("25 * 17 + 130"))}
]

final_response = httpx.post(
    f"{BASE_URL}/chat/completions",
    headers={
        "Authorization": f"Bearer {API_KEY}",
        "Content-Type": "application/json"
    },
    json={
        "model": "gpt-4o",
        "messages": nachrichten
    }
)

print("Finale Antwort:")
print(final_response.json()["choices"][0]["message"]["content"])

Praxisbeispiel: Vollständiger Workflow

In meiner täglichen Arbeit mit HolySheep AI habe ich diesen Workflow für einen automatisierten Kundenservice-Chatbot verwendet. Die Ergebnisse waren beeindruckend:

Häufige Fehler und Lösungen

Fehler 1: Authentifizierungsfehler 401

Problem: Du erhältst die Fehlermeldung „Invalid API key" oder Statuscode 401.

# FALSCH - API-Key mit Leerzeichen oder falsches Format
API_KEY = " YOUR_HOLYSHEEP_API_KEY "  # Leerzeichen!
API_KEY = "sk-xxx"  # Altes OpenAI-Format funktioniert nicht!


RICHTIG - API-Key direkt aus dem Dashboard kopieren

API_KEY = "DEIN_EIGENER_KEY_VON_HOLYSHEEP"  # Ohne Anführungszeichen innen!

Lösung: Kopiere den API-Key exakt aus dem HolySheep Dashboard. Entferne alle führenden/trailenden Leerzeichen. Stelle sicher, dass du https://api.holysheep.ai/v1 als Basis-URL verwendest.

Fehler 2: Function Arguments nicht als JSON-parsbar

Problem: json.loads(arguments) wirft einen Fehler.

# PROBLEM: Die KI gibt manchmal ungültiges JSON zurück

arguments = '{"ort": München}'  # Fehlende Anführungszeichen bei München



LÖSUNG: Robusten JSON-Parser verwenden

import json

def parse_function_args(args_str):
    """Versucht verschiedene JSON-Formate zu parsen"""
    try:
        return json.loads(args_str)
    except json.JSONDecodeError:
        # Versuche mit erzwungenem JSON-Format
        args_str = args_str.replace("'", '"')
        return json.loads(args_str)

Lösung: Implementiere einen robusten Parser mit Fallback-Strategien. Die KI gibt manchmal leicht abweichende JSON-Formate zurück.

Fehler 3: Tool-Call-ID nicht in zweiter Anfrage enthalten

Problem: Die finale Antwort der KI ist „Ich habe die Funktion aufgerufen" ohne eigentliches Ergebnis.

# FALSCH -tool_call_id fehlt in der Tool-Nachricht
nachrichten = [
    {"role": "user", "content": "Wie ist das Wetter?"},
    {"role": "assistant", "content": None, "tool_calls": tool_calls},
    {"role": "tool", "content": '{"temperatur": 22}'}  # Fehlt: tool_call_id!
]


RICHTIG - Jede Tool-Nachricht muss die passende ID haben

for aufruf in tool_calls:
    tool_nachricht = {
        "role": "tool",
        "tool_call_id": aufruf["id"],  # Diese ID ist entscheidend!
        "content": json.dumps(funktions_ergebnis)
    }
    nachrichten.append(tool_nachricht)

Lösung: Die tool_call_id ist der Link zwischen dem Aufruf der KI und deiner Antwort. Ohne diese ID weiß die KI nicht, welches Ergebnis zu welchem Aufruf gehört.

Preisübersicht für Function Calling

Bei HolySheep AI sind die Kosten transparent und günstig (Kurs ¥1 = $1, über 85% Ersparnis gegenüber Alternativen):

Für Function Calling empfehle ich DeepSeek V3.2 für einfache Aufgaben (Kosten ca. 0.04 Cent pro Aufruf) und GPT-4o für komplexe, mehrstufige Workflows.

Fortgeschrittene Tipps aus der Praxis

Nach über 100 produzierten Function-Calling-Implementierungen hier meine wichtigsten Learnings:

Fazit

Function Calling ist eine der mächtigsten Fähigkeiten moderner KI-Modelle. Damit verwandelst du eine passive Textmaschine in einen aktiven Assistenten, der echte Aufgaben erledigen kann. Der Einstieg ist einfacher, als du vielleicht denkst – besonders mit der guten Dokumentation und dem günstigen Preis von HolySheep AI.

Meine Empfehlung: Starte mit dem obigen Demo-Code, experimentiere mit eigenen Funktionen (z.B. eine To-Do-Liste, einen Währungsrechner oder eine知识库-Suche), und du wirst schnell verstehen, wie flexibel dieses System ist.

Viel Erfolg beim Programmieren! 🚀

👉 Registrieren Sie sich bei HolySheep AI — Startguthaben inklusive

Verwandte Ressourcen

Verwandte Artikel