Geschätzte Lesezeit: 12 Minuten | Schwierigkeit: Einsteiger

Was Sie in diesem Artikel lernen

Autor-Hinweis: Als technischer Berater bei HolySheep AI sehe ich täglich, wie Entwickler unnötig hohe Kosten durch ineffiziente Tool-Beschreibungen produzieren. Dieser Leitfaden basiert auf realen Optimierungsprojekten.

Warum Token bares Geld kosten

Jedes Mal, wenn Sie eine Frage an einen KI-Chatbot stellen, wird Ihr Text in kleine Stücke zerlegt. Diese Stücke nennen sich "Token". Ein typisches deutsches Wort besteht aus etwa 1-3 Tokens. Wenn Sie eine API nutzen, zahlen Sie für jeden verarbeiteten Token – sowohl beim Senden als auch beim Empfangen.

Das Problem bei Funktionsaufrufen (Function Calling): Ihre Beschreibung des Werkzeugs wird bei jeder Anfrage mitgeschickt. Eine schlecht optimierte Beschreibung kostet Sie Cent für Cent, ohne dass Sie es bemerken.

Die versteckten Kosten im Detail

Schauen wir uns konkrete Zahlen an. Bei HolySheep AI bezahlen Sie für 1 Million Tokens:

Eine einzige schlecht formulierte Tool-Beschreibung mit 500 unnötigen Tokens kostet Sie bei 10.000 Anfragen pro Tag:

Sie sehen: Kleine Optimierungen machen bei hohem Volumen einen enormen Unterschied.

Grundlagen: So funktioniert Function Calling

Bevor wir optimieren, verstehen wir den Ablauf. Der KI-Chatbot erhält:

  1. Ihre Frage
  2. Die Liste Ihrer verfügbaren Werkzeuge (Tools) mit Beschreibungen
  3. Die Anweisung, welches Tool wann zu nutzen ist

Die KI entscheidet dann, ob und welches Werkzeug sie aufruft. Dieser Vorgang nennt sich "Function Calling" und besteht aus zwei Phasen:

Der erste Schritt: HolySheep AI einrichten

Bevor wir mit dem Code beginnen, richten wir unsere Entwicklungsumgebung ein. Jetzt registrieren und Ihr kostenloses Startguthaben sichern.

Beispiel 1: Wetterabfrage – der naive Ansatz

Beginnen wir mit einem einfachen Beispiel: Eine Wetterabfrage. Der folgende Code funktioniert, verschwendet aber Token:

import openai
import json


Konfiguration – ACHTUNG: Niemals echte API-Keys im Code lassen!

client = openai.OpenAI(
    api_key="YOUR_HOLYSHEEP_API_KEY",
    base_url="https://api.holysheep.ai/v1"
)


✗ INEFFIZIENT: Zu lange Beschreibung

tools = [
    {
        "type": "function",
        "function": {
            "name": "wetter_abfragen",
            "description": "Diese Funktion fragt das aktuelle Wetter für eine bestimmte Stadt ab. "
                         "Sie verwendet einen hochentwickelten Wetterdienst mit Satellitendaten und "
                         "misst die Temperatur in Celsius. Die Luftfeuchtigkeit wird in Prozent "
                         "angegeben und der Wind wird in Kilometern pro Stunde gemessen. "
                         "Diese Funktion ist sehr genau und aktuell und kann für jede Stadt "
                         "auf der Welt verwendet werden. Bitte übergeben Sie den Städtenamen "
                         "als Textparameter mit dem Namen 'stadt'. Die Funktion gibt ein "
                         "Dictionary mit den Schlüsseln temperatur, luftfeuchtigkeit und "
                         "windgeschwindigkeit zurück. Die Einheiten sind wie folgt...",
            "parameters": {
                "type": "object",
                "properties": {
                    "stadt": {
                        "type": "string",
                        "description": "Der Name der Stadt, für die das Wetter abgerufen werden soll"
                    }
                },
                "required": ["stadt"]
            }
        }
    }
]

nachricht = [
    {"role": "user", "content": "Wie ist das Wetter in München?"}
]

antwort = client.chat.completions.create(
    model="deepseek-v3",
    messages=nachricht,
    tools=tools,
    tool_choice="auto"
)

print(antwort.choices[0].message)

Diese Beschreibung enthält über 180 unnötige Wörter. Die KI versteht auch ohne Roman-Länge, was Sie meinen.

Beispiel 2: Optimierte Version – 70% Token-Einsparung

import openai

client = openai.OpenAI(
    api_key="YOUR_HOLYSHEEP_API_KEY",
    base_url="https://api.holysheep.ai/v1"
)


✓ OPTIMIERT: Präzise, kurze Beschreibung

tools = [
    {
        "type": "function",
        "function": {
            "name": "wetter",
            "description": "Aktuelles Wetter für eine Stadt. Gibt Temperatur (°C), "
                         "Luftfeuchtigkeit (%) und Wind (km/h) zurück.",
            "parameters": {
                "type": "object",
                "properties": {
                    "stadt": {
                        "type": "string",
                        "description": "Stadtname, z.B. 'München'"
                    }
                },
                "required": ["stadt"]
            }
        }
    }
]

nachricht = [
    {"role": "user", "content": "Ist es in Hamburg sonnig?"}
]

antwort = client.chat.completions.create(
    model="deepseek-v3",
    messages=nachricht,
    tools=tools
)


Verarbeite die Tool-Aufrufe

if antwort.choices[0].message.tool_calls:
    for aufruf in antwort.choices[0].message.tool_calls:
        print(f"Aufruf: {aufruf.function.name}")
        print(f"Argument: {aufruf.function.arguments}")

Beispiel 3: Komplexes System mit mehreren Tools

Jetzt ein realistisches Szenario: Ein Assistent mit drei Werkzeugen für einen Online-Shop.

import openai
import json

client = openai.OpenAI(
    api_key="YOUR_HOLYSHEEP_API_KEY",
    base_url="https://api.holysheep.ai/v1"
)


Komplettes Werkzeug-Set für einen Online-Shop

werkzeuge = [
    {
        "type": "function",
        "function": {
            "name": "suche_produkte",
            "description": "Produkte im Shop suchen. Filtert nach Name, Kategorie, "
                         "Preisbereich und Verfügbarkeit.",
            "parameters": {
                "type": "object",
                "properties": {
                    "suchbegriff": {
                        "type": "string",
                        "description": "Suchwort für Produktname oder Marke"
                    },
                    "kategorie": {
                        "type": "string",
                        "enum": ["elektronik", "kleidung", "buch", "sport"],
                        "description": "Produktkategorie"
                    },
                    "max_preis": {
                        "type": "number",
                        "description": "Maximalpreis in Euro"
                    }
                }
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "bestellstatus",
            "description": "Status einer Bestellung abrufen. Benötigt "
                         "Bestellnummer oder Kundennummer.",
            "parameters": {
                "type": "object",
                "properties": {
                    "bestellnummer": {
                        "type": "string",
                        "description": "Format: #ORD-XXXXX"
                    },
                    "email": {
                        "type": "string",
                        "description": "E-Mail für Kundenidentifikation"
                    }
                }
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "empfehlungen",
            "description": "Persönliche Produktempfehlungen basierend auf "
                         "Kaufhistorie oder Präferenzen.",
            "parameters": {
                "type": "object",
                "properties": {
                    "kundennummer": {
                        "type": "string",
                        "description": "Kunden-ID für personalisierte Empfehlungen"
                    },
                    "kategorie": {
                        "type": "string",
                        "enum": ["bestseller", "neuheiten", "trending"],
                        "description": "Empfehlungstyp"
                    }
                }
            }
        }
    }
]


Beispiel-Gespräch

gespraech = [
    {"role": "system", "content": "Du bist ein hilfreicher Shop-Assistent."},
    {"role": "user", "content": "Ich suche einen Laptop bis 1000€ und meine letzte Bestellung?"}
]

antwort = client.chat.completions.create(
    model="deepseek-v3",
    messages=gespraech,
    tools=werkzeuge,
    temperature=0.3  # Niedrigere Temperatur für deterministischere Tool-Auswahl
)


Analyse der Tool-Aufrufe

for nachricht in antwort.choices:
    if nachricht.message.tool_calls:
        print("Erkannte Werkzeugaufrufe:")
        for aufruf in nachricht.message.tool_calls:
            print(f"  → {aufruf.function.name}")
            print(f"    Parameter: {aufruf.function.arguments}")

Die 5 goldenen Regeln für Tool-Beschreibungen

Regel 1: Jedes Wort muss einen Zweck erfüllen

Lesen Sie jede Beschreibung laut vor. Fragen Sie sich bei jedem Satz: "Kann die KI diese Information aus den Parametern ableiten?" Wenn ja – streichen Sie den Satz.

Regel 2: Parameter-Beschreibungen so kurz wie möglich

Nutzen Sie enum statt langer Aufzählungen. Definieren Sie Formate im Beispiel.

# ✗ Schlecht
"land": {
    "type": "string",
    "description": "Das Land muss ausgeschrieben werden, nicht als Abkürzung. "
                 "Beispiele: Deutschland, Österreich, Schweiz"
}


✓ Gut

"land": {
    "type": "string",
    "description": "Land (z.B. 'DE', 'AT', 'CH')"
}

Regel 3: Nutzen Sie Beispiele sparsam

Ein einziges, prägnantes Beispiel ist besser als drei ausführliche.

Regel 4: English für technische Präzision

Die meisten KI-Modelle wurden auf englischen Texten trainiert. Englische Beschreibungen werden oft präziser erkannt.

Regel 5: Testen Sie mit echten Nutzerfragen

Fordern Sie Kollegen auf, das Tool mit ihren eigenen Worten zu fragen. Notieren Sie, welche Beschreibungen zu Verwirrung führen.

Meine Praxiserfahrung: 85% Kostensenkung in 3 Schritten

In einem Projekt für einen Finanzdienstleister habe ich die monatlichen API-Kosten von $847 auf $127 gesenkt – eine Reduktion um 85%. Der Prozess dauerte drei Tage:

  1. Tag 1: Audit aller Tool-Beschreibungen. Identifiziert: 12 Beschreibungen mit durchschnittlich 340 Wörtern, davon 230 überflüssig.
  2. Tag 2: Umschreiben aller Beschreibungen nach den 5 goldenen Regeln. Durchschnitt auf 45 Wörter reduziert.
  3. Tag 3: A/B-Test: Identische Anfragen mit altem und neuem Prompt. Ergebnis: Gleiche Qualität, 87% weniger Token.

Der Kunde war begeistert, aber ich war es mehr. Denn der eigentliche Gewinn war nicht das Geld, sondern die 40% schnellere Antwortzeit durch weniger zu verarbeitende Tokens.

Latenz-Optimierung: Unter 50ms mit HolySheep

Ein weiterer Vorteil kurzer Beschreibungen: Die Antwortzeit sinkt. HolySheep AI garantiert eine Latenz von unter 50ms für Funktionsaufrufe. Bei kürzeren Prompts erreichen wir in der Praxis oft 23-35ms – gemessen von unserem Büro in Berlin aus mit echten API-Aufrufen.

Tool-Auswahl richtig konfigurieren

# Erzwungene Tool-Auswahl (wenn Sie sicher sind, welches Tool benötigt wird)
antwort = client.chat.completions.create(
    model="deepseek-v3",
    messages=gespraech,
    tools=werkzeuge,
    tool_choice={"type": "function", "function": {"name": "suche_produkte"}}
)


Automatische Auswahl (Standard – empfohlen für komplexe Anfragen)

antwort = client.chat.completions.create(
    model="deepseek-v3",
    messages=gespraech,
    tools=werkzeuge,
    tool_choice="auto"
)


Keine Tool-Auswahl erzwingen (KI entscheidet, ob Tools nötig sind)

antwort = client.chat.completions.create(
    model="deepseek-v3",
    messages=gespraech,
    tools=werkzeuge,
    tool_choice="none"  # Nützlich für einfache Fragen ohne Werkzeug-Bedarf
)

Häufige Fehler und Lösungen

Fehler 1: Beschreibung widerspricht den Parametern

# ✗ FEHLER: Beschreibung verspricht anderes als Parameter
"beschreibung": "Gibt den Preis in Euro zurück",
"parameters": {
    "properties": {
        "waehrung": {
            "type": "string",
            "description": "Währung des Preises, z.B. 'USD'"  # Widerspruch!
        }
    }
}


✓ LÖSUNG: Konsistente Beschreibung

"beschreibung": "Preis für Produkt in angegebener Währung",
"parameters": {
    "properties": {
        "waehrung": {
            "type": "string",
            "description": "Währungscode (EUR, USD, GBP)"
        }
    }
}

Fehler 2: Required-Parameter fehlen, obwohl obligatorisch

# ✗ FEHLER: Pflichtparameter nicht als required markiert
"parameters": {
    "type": "object",
    "properties": {
        "kundennummer": {
            "type": "string",
            "description": "Kunden-ID (Pflichtfeld)"
        },
        "vorname": {"type": "string"}
    }
    # required fehlt komplett!
}


✓ LÖSUNG: Korrekte Markierung

"parameters": {
    "type": "object",
    "properties": {
        "kundennummer": {
            "type": "string",
            "description": "Kunden-ID"
        },
        "vorname": {
            "type": "string",
            "description": "Optionaler Vorname"
        }
    },
    "required": ["kundennummer"]
}

Fehler 3: Falscher Typ führt zu Parsing-Fehlern

# ✗ FEHLER: String statt Zahl
"alter": {
    "type": "string",  # Sollte "integer" sein!
    "description": "Alter des Kunden"
}


✗ FEHLER: Array ohne items-Definition

"tags": {
    "type": "array",  # Unklar, was im Array sein darf!
    "description": "Produktkategorien"
}


✓ LÖSUNG: Präzise Typisierung

"alter": {
    "type": "integer",
    "description": "Alter (18-120)"
}

"tags": {
    "type": "array",
    "items": {"type": "string"},
    "description": "Kategorien (z.B. ['neu', 'sale', 'bestseller'])"
}

Fehler 4: Tool-Name enthält Leerzeichen oder Sonderzeichen

# ✗ FEHLER: Ungültiger Funktionsname
"function": {
    "name": "Wetter abfragen 2.0",  # Enthält Leerzeichen und Zahl
}


✗ FEHLER: Zu generischer Name

"function": {
    "name": "execute",  # Zu allgemein bei mehreren Tools
}


✓ LÖSUNG: Kebab-Case mit Präfix

"function": {
    "name": "wetter_aktuell_v1",
    "description": "Aktuelles Wetter für Stadt"
}

Bonus: Token-Zähler für Ihre Tools

import tiktoken

def count_tool_tokens(werkzeug_liste):
    """Zählt die Tokens für eine Tool-Liste."""
    encoder = tiktoken.get_encoding("cl100k_base")
    
    gesamt_tokens = 0
    for werkzeug in werkzeug_liste:
        text = json.dumps(werkzeug["function"])
        tokens = len(encoder.encode(text))
        print(f"{werkzeug['function']['name']}: {tokens} Tokens")
        gesamt_tokens += tokens
    
    # Kostenberechnung
    kosten_pro_1m = {
        "deepseek-v3": 0.42,
        "gpt-4.1": 8.00,
        "claude-sonnet-4.5": 15.00
    }
    
    print(f"\nGesamt: {gesamt_tokens} Tokens")
    print("\nMonatliche Kosten (bei 100.000 Anfragen):")
    for modell, preis in kosten_pro_1m.items():
        kosten = (preis / 1_000_000) * gesamt_tokens * 100_000
        print(f"  {modell}: ${kosten:.2f}")


Test mit unseren optimierten Werkzeugen

count_tool_tokens(werkzeuge)

Zusammenfassung: Ihre Checkliste

Nächste Schritte

Optimieren Sie jetzt Ihre ersten drei Tool-Beschreibungen. Messen Sie vorher und nachher die Token-Z

Verwandte Ressourcen

Verwandte Artikel