Ihr Handbuch für GLM 4.5 Funktionsaufrufe: Von der Integration bis zur Fehlerbehebung

GLM 4.5 ist ein fortschrittliches Large Language Model (LLM) mit Agent-Funktionen, das Automatisierung und intelligente Entscheidungsfindung durch Funktionsaufrufe auf die nächste Stufe hebt. Durch die Nutzung von Funktionsaufrufen kann GLM 4.5 mit externen Tools und APIs interagieren, Aktionen ausführen, Daten abrufen und komplexe Workflows automatisieren – es ist also weit mehr als nur ein konversationelles Modell.

Die Integration und Fehlerbehebung von Funktionsaufrufen kann jedoch herausfordernd sein. Dieser Artikel bietet praktische Anleitungen und Lösungen für häufige Probleme, die bei der Nutzung von Funktionsaufrufen mit GLM 4.5 auftreten können, wie z. B. Parser-Fehler, falsche Ausgabeformate oder Fallstricke beim Schema-Design. Anhand klarer Beispiele, Fehlerbehebungstipps und Best Practices hilft Ihnen dieser Artikel, Probleme schnell zu erkennen und zu beheben – sodass Sie das agentische Potenzial von GLM 4.5 in Ihren realen Anwendungen voll ausschöpfen können.

Welche besseren Ergebnisse können Funktionsaufrufe für GLM 4.5 erzielen?

Funktionsaufrufe sind eine leistungsstarke Funktion, die in Large Language Models wie GLM 4.5 eingeführt wurde. Sie ermöglicht es dem Modell, auf kontrollierte und zuverlässige Weise mit externen Tools, APIs oder strukturiertem Code zu interagieren. Hier sind die wichtigsten Vorteile und verbesserten Ergebnisse, die Funktionsaufrufe für GLM 4.5 mit sich bringen:

https://www.youtube.com/watch?v=KUEmEb71vzQ

1. Genauere und zuverlässigere Ausgaben

• Verbesserte Faktenrichtigkeit: Durch die Delegation von Aufgaben wie Berechnungen, Datenabfragen oder Datenbankanfragen an externe Funktionen kann GLM 4.5 Fehler vermeiden, die bei rein textbasierten Antworten häufig auftreten.
• Weniger Halluzinationen: Das Modell verlässt sich auf verifizierte Ergebnisse von APIs oder Funktionen, wodurch die Wahrscheinlichkeit verringert wird, falsche oder erfundene Informationen zu generieren.

2. Automatisierung komplexer Aufgaben

• Aufgabenverkettung: GLM 4.5 kann eine Benutzeranfrage in mehrere Schritte aufteilen, für jeden Schritt passende Funktionen aufrufen und die Ergebnisse kombinieren.
• Workflow-Automatisierung: Es kann mehrstufige Geschäftsprozesse, Datenverarbeitung oder Berichterstellung durch die Orchestrierung von Folgen von Funktionsaufrufen automatisieren.

3. Verbesserte Integration mit realen Systemen

• Zugriff auf Echtzeitdaten: Durch Funktionsaufrufe kann das Modell Echtzeitinformationen aus Datenbanken, Webdiensten oder IoT-Geräten abrufen, sodass seine Antworten aktueller und kontextbewusster sind.
• Benutzerdefinierte Aktionen: Unternehmen können benutzerdefinierte Funktionen (z. B. das Versenden von E-Mails, das Aufgeben von Bestellungen) definieren, sodass das Modell domänenspezifische Aktionen sicher ausführen kann.

4. Verbesserte Benutzererfahrung

• Interaktive Anwendungen: Benutzer können mit dem Modell interagieren, als würden sie eine App nutzen, wobei das Modell Backend-Funktionen transparent auslöst.
• Personalisierung: Funktionen können benutzerspezifische Daten oder Einstellungen abrufen, sodass personalisierte Antworten möglich sind.

5. Bessere Fehlerbehandlung und Erklärbarkeit

• Transparente Begründung: Funktionsaufrufe helfen nachzuverfolgen, welche externen Ressourcen oder Tools verwendet wurden, sodass der Begründungsprozess des Modells besser nachvollziehbar ist.
• Kontrollierte Ausführung: Entwickler können überwachen und einschränken, welche Funktionen das Modell aufrufen kann, was Sicherheit und Vorhersagbarkeit verbessert.

Welche Einschränkungen haben Funktionsaufrufe in GLM-4.5?

1. Übermäßige Aufrufe
GLM-4.5 kann manchmal übermäßige oder unnötige Aufrufe an externe Tools oder APIs tätigen. Dies erhöht den Token-Verbrauch und die Betriebskosten, da mehr Rechenressourcen verbraucht werden, ohne dass das Endergebnis immer davon profitiert.

2. Streaming-Sonderfälle
Im Streaming-Modus können nachgelagerte Anwendungen unvollständige Informationen erhalten, wenn partielle JSON-Daten gesendet werden, bevor die vollständige Antwort fertig ist. Ohne ordnungsgemäße Pufferung kann dies zu Fehlern oder Ausfällen bei der Verarbeitung der Ausgabe führen.

3. Ressourcenbedarf
Bei Funktionsaufrufen bedeutet dies, dass begrenzte Hardware-Ressourcen die Fähigkeit des Modells beeinträchtigen können, effizient eine große Anzahl von Anfragen zu verarbeiten, komplexe Daten zu verarbeiten oder intricate Ketten von Tool-Aufrufen auszuführen. In ressourcenbegrenzten Umgebungen können Leistung und Genauigkeit von Funktionsaufrufen deutlich reduziert sein.

Vorteile der Nutzung von Funktionsaufrufen mit GLM-4.5

Eine unabhängige Bewertung der agentischen Codierungsfähigkeiten von GLM-4.5 wurde mit Claude Code durchgeführt und umfasste 52 verschiedene Codierungsaufgaben wie Frontend-Entwicklung, Tool-Erstellung, Datenanalyse, Testing und Algorithmus-Implementierung. GLM-4.5 erreichte eine führende Erfolgsquote bei Tool-Aufrufen von 90,6 % und übertraf damit Claude-4-Sonnet (89,5 %), Kimi K2 (86,2 %) und Qwen3-Coder (77,1 %).

Tutorial: Nutzung von Funktionsaufrufen in GLM-4.5 für Einsteiger

Diese Anleitung zeigt, wie Sie Funktionsaufrufe nutzen, um aktuelle Wetterinformationen für einen vom Benutzer angegebenen Ort abzurufen. Wir gehen ein vollständiges Python-Codebeispiel durch.

Für das spezifische API-Format von Funktionsaufrufen lesen Sie bitte die Dokumentation!

Probieren Sie GLM 4.5 jetzt aus!

• Initialisieren Sie den Client

from openai import OpenAI
import json

client = OpenAI(
    base_url="https://api.novita.ai/v3/openai",
    # Get the Novita AI API Key from: https://novita.ai/settings/key-management.
    api_key="<YOUR Novita AI API Key>",
)

model = "zai-org/glm-4.5"

• Definieren Sie die aufzurufende Funktion

# Example function to simulate fetching weather data.
def get_weather(location):
    """Retrieves the current weather for a given location."""
    print("Calling get_weather function with location: ", location)
    # In a real application, you would call an external weather API here.
    # This is a simplified example returning hardcoded data.
    return json.dumps({"location": location, "temperature": "60 degrees Fahrenheit"})

• Erstellen Sie die API-Anfrage mit Tools und Benutzer-Nachricht

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Get weather of an location, the user shoud supply a location first",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "The city and state, e.g. San Francisco, CA",
                    }
                },
                "required": ["location"]
            },
        }
    },
]

messages = [
    {
        "role": "user",
        "content": "What is the weather in San Francisco?"
    }
]

# Let's send the request and print the response.
response = client.chat.completions.create(
    model=model,
    messages=messages,
    tools=tools,
)

# Please check if the response contains tool calls if in production.
tool_call = response.choices[0].message.tool_calls[0]
print(tool_call.model_dump())

• Ausgabe

{'id': '0', 'function': {'arguments': '{"location": "San Francisco, CA"}', 'name': 'get_weather'}, 'type': 'function'}

• Antworten Sie mit dem Ergebnis des Funktionsaufrufs und erhalten Sie die finale Antwort

# Ensure tool_call is defined from the previous step
if tool_call:
    # Extend conversation history with the assistant's tool call message
    messages.append(response.choices[0].message)

    function_name = tool_call.function.name
    if function_name == "get_weather":
        function_args = json.loads(tool_call.function.arguments)
        # Execute the function and get the response
        function_response = get_weather(
            location=function_args.get("location"))
        # Append the function response to the messages
        messages.append(
            {
                "tool_call_id": tool_call.id,
                "role": "tool",
                "content": function_response,
            }
        )

    # Get the final response from the model, now with the function result
    answer_response = client.chat.completions.create(
        model=model,
        messages=messages,
        # Note: Do not include tools parameter here.
    )
    print(answer_response.choices[0].message)

• Ausgabe

{'id': '0', 'function': {'arguments': '{"location": "San Francisco, CA"}', 'name': 'get_weather'}, 'type': 'function'}

Novita AI bietet jetzt Kompatibilität mit dem Anthropic SDK

Die Kombination aus GLM-4.5 und Claude Code hat schnell Aufmerksamkeit in der KI-Community erregt und bietet fortschrittliche agentische Fähigkeiten für reale Anwendungen. Um diese Integration weiter zu vereinfachen, bietet Novita AI jetzt Kompatibilität mit dem Anthropic SDK, sodass Sie die Leistung von GLM-4.5 einfach über die vertraute Claude Code-Oberfläche nutzen können.

Weitere Details finden Sie in dieser Dokumentation!

1. Installieren Sie das Anthropic SDK

pip install anthropic

2. Initialisieren Sie den Client Die Anthropic SDKs sind dafür ausgelegt, den API-Schlüssel und die Basis-URL aus den Umgebungsvariablen ANTHROPIC_API_KEY und ANTHROPIC_BASE_URL zu ziehen. Sie können die Parameter auch beim Initialisieren des Anthropic-Clients angeben. Ihre API-Schlüssel können Sie auf der Einstellungsseite einsehen und verwalten.

• Nutzung von Umgebungsvariablen

export ANTHROPIC_BASE_URL="https://api.novita.ai/anthropic"
export ANTHROPIC_API_KEY="<YOUR_NOVITA_API_KEY>"

• Geben Sie die Parameter beim Initialisieren des Anthropic-Clients an

import anthropic

client = anthropic.Anthropic(
    base_url="https://api.novita.ai/anthropic",
    api_key="<YOUR_NOVITA_API_KEY>"
)

3. Rufen Sie die API auf

import anthropic

# Initialize the client, if you already set `ANTHROPIC_BASE_URL` and `ANTHROPIC_API_KEY` 
# in the environment variables, you can omit the `api_key` and `base_url` parameters.
client = anthropic.Anthropic(
    base_url="https://api.novita.ai/anthropic",
    api_key="<YOUR_NOVITA_API_KEY>"
)

message = client.messages.create(
    model="zai-org/glm-4.5",
    max_tokens=1000,
    temperature=1,
    system="You are a world-class poet. Respond only with short poems.",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text": "Why is the ocean salty?"
                }
            ]
        }
    ]
)

print(message.content)

So verbessern Sie die Genauigkeit von Funktionsaufrufen mit GLM-4.5

1. Schema-Klarheit

• Was es bedeutet: Verwenden Sie kurze, eindeutige Parameternamen und vermeiden Sie verschachteltes anyOf, bis der Parser robuster ist.
• Was es löst: Verhindert Parameterverwirrung und Namenskonflikte, sodass das Modell Argumente einfacher korrekt ausfüllen kann. Reduziert Parsing-Fehler und fehlgeschlagene Funktionsaufrufe, die durch übermäßig komplexe Schemas verursacht werden.

2. System-Prompt

• Was es bedeutet: Weisen Sie das Modell an, „zuerst zu entscheiden, ob ein Tool benötigt wird; andernfalls antworten Sie direkt“.
• Was es löst: Reduziert unnötige oder übermäßige Tool-/Funktionsaufrufe (übermäßige Aufrufe). Hilft, Rechenressourcen und Betriebskosten zu sparen.

3. Temperatur ≤ 0.2

• Was es bedeutet: Setzen Sie den Temperaturparameter auf 0.2 oder niedriger.
• Was es löst: Verringert die Zufälligkeit der Ausgabe, sodass das Verhalten vorhersagbarer und konsistenter ist. Verhindert Schema-Drift, sodass das Modell an der beabsichtigten Parameterstruktur festhält und Fehler reduziert.

4. Nutzen Sie tool_choice="required"

• Was es bedeutet: Setzen Sie diese Option, wenn der Benutzer explizit einen Funktionsaufruf anfordert.
• Was es löst: Stellt sicher, dass das Modell immer den erforderlichen Funktionsaufruf tätigt, was Zuverlässigkeit und Benutzerzufriedenheit verbessert.

5. Parallele Aufrufe nur sparsam nutzen

• Was es bedeutet: Parallelisieren Sie nur wirklich unabhängige Funktionen; andernfalls generieren Sie Aufrufe sequenziell.
• Was es löst: Verhindert Argumentvermischung oder logische Inkonsistenz zwischen Aufrufen. Stellt sicher, dass jeder Aufruf den korrekten Kontext und die korrekten Eingaben erhält, was zu genaueren Ergebnissen führt.

Fehlerbehebung bei Funktionsaufrufen mit GLM-4.5

Symptom	Häufige Ursache	Behebung / Lösung
IndexError: list index out of range in parser	Verwendung des Standardparsers; GLM-ID-Format weicht ab.	Starten Sie den Server mit --tool-call-parser glm4_moe.
Zufälliger Text, der mit JSON vermischt ist	Temperatur zu hoch oder fehlendes tool_choice.	Senken Sie die Temperatur; setzen Sie tool_choice auf "auto" oder "required".
Endlose Tool-Rekursion	Modell halluziniert wiederholte Aufrufe.	Verfolgen Sie ausgeführte Aufrufe und brechen Sie Duplikate in der Host-Logik ab.
OOM / OutOfResources	FP8-Build überschreitet immer noch den Shared Memory auf Triton-Kerneln.	Reduzieren Sie num_stages oder wechseln Sie zur Int4-Int8-Mix-Quantisierung.
Kein Aufruf ausgegeben	Tool-Schema zu vage.	Fügen Sie eine strikte required-Liste und explizite Enum-Werte hinzu.

Funktionsaufrufe verwandeln GLM 4.5 von einem konversationellen Modell in einen intelligenten Agenten, der Aufgaben in Echtzeit ausführen und Prozesse automatisieren kann. Durch das Verständnis typischer Probleme und ihrer Lösungen – wie Parser-Fehler, JSON-Formatierung oder Schema-Design – können Sie eine reibungslose Integration sicherstellen und das volle Potenzial der agentischen Fähigkeiten von GLM 4.5 ausschöpfen. Wir hoffen, dass dieser Artikel häufige Fragen geklärt und Sie befähigt hat, Funktionsaufrufe mit GLM 4.5 selbstbewusst einzusetzen.

Häufig gestellte Fragen

Warum sind Funktionsaufrufe für GLM 4.5 als agentisches LLM wichtig? Funktionsaufrufe ermöglichen es GLM 4.5, programmatisch mit externen Diensten, Datenbanken und Tools zu interagieren. Dies ermöglicht Automatisierung, mehrstufige Schlussfolgerung, Informationsabruf und reale Aktionen jenseits der Textgenerierung.

Wie vermeide ich endlose Rekursion oder wiederholte Tool-Aufrufe? Implementieren Sie Host-seitige Logik, um doppelte Funktionsaufrufe zu verfolgen und abzubrechen, sodass Endlosschleifen verhindert werden.

Welche Best Practices gibt es für das Schema-Design, um sicherzustellen, dass Funktionsaufrufe ausgegeben werden? Verwenden Sie prägnante, eindeutige Parameternamen, geben Sie explizite Enums an und definieren Sie erforderliche Parameter, um das Schema für das Modell verständlich zu machen.

Novita AI ist die All-in-One-Cloud-Plattform, die Ihre KI-Ambitionen verwirklicht. Integrierte APIs, Serverless, GPU-Instanzen – die kostengünstigen Tools, die Sie brauchen. Eliminieren Sie Infrastruktur, starten Sie kostenlos und machen Sie Ihre KI-Vision zur Realität.

Empfohlene Lektüre

• Ein Leitfaden für den Zugriff auf DeepSeek V3: Lokal und per API
• DeepSeek V3 vs R1: Stufenweises Training vs iterative SFT-RL-Zyklen
• GLM 4.1V 9B Thinking VRAM: Reicht eine A100 aus?