DeepSeek V4 Pro API: Function Calling nutzen – Eine Anleitung

DeepSeek hat V4 Pro am 12. August 2026 aus der Vorschauphase entlassen. Die Berichterstattung zur Markteinführung hebt agentische Workflows hervor: Code schreiben, Tools verwenden und Langzeitaufgaben über Dutzende Schritte hinweg ausführen. Dafür ist ein API-Feature zentral: Funktionsaufrufe. Dieser Artikel zeigt, wie Sie Tool-Schemas definieren, Tool-Aufrufe mit dem Python-openai-SDK ausführen, einen Agenten-Loop bauen und die Requests vor dem Deployment in Apidog testen.

Apidog noch heute ausprobieren

Wenn Sie noch keinen API-Schlüssel haben, richten Sie ihn mit dem Leitfaden zur Nutzung der DeepSeek V4 API ein und kommen Sie dann hierher zurück.

Kurzfassung

• deepseek-v4-pro (GA-Build DeepSeek-V4-Pro-0813) unterstützt Funktionsaufrufe im OpenAI-Stil: Sie senden ein tools-Array, erhalten tool_calls und geben Ergebnisse als tool-Nachrichten zurück.
• Mit dem Standard-openai-SDK benötigen Sie nur base_url="https://api.deepseek.com".
• Ein robuster Agenten-Loop besteht aus wenigen Schritten: Modell aufrufen, Tool-Aufrufe validieren und ausführen, Ergebnisse anhängen, wiederholen.
• Tool-Aufrufe können parallel erfolgen. Für schwierige Planungsrunden ist außerdem ein Denkmodus mit reasoning_content verfügbar.
• Die Qualität hängt stark von Tool-Schemas, Prompts und Ihrem Runtime-Harness ab. Testen Sie deshalb reale Tools und reale Payloads.

Warum Tool-Aufrufe der Hauptanwendungsfall von V4 Pro sind

DeepSeek positioniert V4 Pro als Modell für Agenten. Die Spezifikationen passen zu typischen Anforderungen einer Agenten-Runtime:

Spezifikation	DeepSeek V4 Pro
Architektur	Sparse MoE: 1,6 T Gesamtparameter, 49 Mrd. aktiv pro Token
Kontextfenster	1 Mio. Tokens
Maximale Ausgabe	384.000 Tokens
Eingabepreis	0,435 $/M Tokens (Cache Miss), 0,003625 $/M (Cache Hit)
Ausgabepreis	0,87 $/M Tokens
Funktionsaufrufe	OpenAI-kompatibles tools-Array und tool_calls-Antworten
Weitere Oberflächen	Anthropic-Messages-Format, DeepSeek Responses API

Ein großes Kontextfenster hält Tool-Ergebnisse und Zwischenschritte im Gespräch. Die Präfix-Zwischenspeicherung senkt dabei die Kosten wiederholter Agenten-Runden. Für Anbietervergleiche ist das Modell auf OpenRouter als deepseek-v4-pro-0813 gelistet.

Wichtig: In der Hacker-News-Launch-Diskussion berichteten Entwickler, dass Tool-Calling-Ergebnisse stark von Framework, Prompt-Struktur und Schema-Stil abhängen. Benchmarks ersetzen deshalb keine Tests mit Ihren tatsächlichen Tool-Definitionen.

Wie DeepSeek-Funktionsaufrufe funktionieren

Ein Funktionsaufruf führt keine Funktion auf DeepSeek-Servern aus. Das Modell erstellt nur eine strukturierte Anforderung, etwa:

{
  "name": "get_order",
  "arguments": "{\"order_id\": \"ORD-10442\"}"
}

Ihre Anwendung führt die Funktion lokal oder gegen Ihre API aus, gibt das Ergebnis zurück und lässt das Modell damit weiterarbeiten.

Der Ablauf:

1. Sie senden messages und ein tools-Array mit JSON-Schema-Definitionen.
2. Das Modell antwortet mit tool_calls und finish_reason: "tool_calls".
3. Ihr Code parst und validiert die Argumente.
4. Ihr Code führt die erlaubte Funktion aus.
5. Sie senden das Ergebnis als role: "tool" zurück, verknüpft über tool_call_id.
6. Das Modell fordert weitere Tools an oder erzeugt die finale Antwort.

Wenn Sie bereits mit OpenAI-Funktionsaufrufen gearbeitet haben, kennen Sie das Wire-Format bereits. Meist reichen Basis-URL und Modellname für die Portierung. Die offizielle DeepSeek-Dokumentation beschreibt auch Anthropic-kompatible Messages und eine Responses API; dieses Tutorial verwendet die OpenAI-kompatible Chat-Completions-Oberfläche.

Schritt 1: Client einrichten

Installieren Sie das SDK und setzen Sie den API-Schlüssel:

pip install openai
export DEEPSEEK_API_KEY="sk-..."

Initialisieren Sie anschließend den Client:

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["DEEPSEEK_API_KEY"],
    base_url="https://api.deepseek.com",
)

Die folgenden Beispiele verwenden model="deepseek-v4-pro", das auf den GA-Build DeepSeek-V4-Pro-0813 verweist.

Schritt 2: Tool-Schema definieren

Als Beispiel bauen wir einen Support-Agenten für einen Online-Shop. Das Tool get_order sucht eine Bestellung anhand ihrer ID.

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_order",
            "description": (
                "Sucht eine Kundenbestellung anhand ihrer ID. Gibt Bestellstatus, "
                "Spediteur, Sendungsverfolgungsnummer und voraussichtliches Lieferdatum zurück. "
                "Verwende dieses Tool, wenn der Benutzer nach dem Standort oder Status "
                "einer Bestellung fragt."
            ),
            "parameters": {
                "type": "object",
                "properties": {
                    "order_id": {
                        "type": "string",
                        "description": "Die Bestell-ID im Format 'ORD-10442'.",
                    }
                },
                "required": ["order_id"],
                "additionalProperties": False,
            },
        },
    }
]

Die Beschreibung ist Teil der Steuerung Ihres Agenten. Das Modell nutzt sie, um zu entscheiden, wann ein Tool aufgerufen werden soll. Formulieren Sie deshalb konkret:

• Welche Daten liefert das Tool?
• In welchen Situationen soll es verwendet werden?
• Welche Eingabeformate erwartet es?
• Wann soll es nicht verwendet werden?

Hier ist eine lokale Stub-Implementierung. In der Produktion ersetzen Sie diese durch einen API-Client oder Service-Aufruf.

def get_order(order_id: str) -> dict:
    """Stub für Ihren echten Bestellservice."""
    fake_db = {
        "ORD-10442": {
            "status": "shipped",
            "carrier": "DHL",
            "tracking_number": "4281337005",
            "estimated_delivery": "2026-08-15",
        },
        "ORD-10587": {
            "status": "processing",
            "estimated_ship_date": "2026-08-14",
        },
    }

    return fake_db.get(
        order_id,
        {"error": f"Unbekannte Bestell-ID: {order_id}"},
    )

Schritt 3: Ersten Tool-Aufruf auslösen

Senden Sie eine Frage, die ohne Bestelldaten nicht beantwortet werden kann:

messages = [
    {
        "role": "system",
        "content": "Sie sind ein Support-Agent für einen Online-Shop.",
    },
    {
        "role": "user",
        "content": "Wo ist meine Bestellung ORD-10442?",
    },
]

response = client.chat.completions.create(
    model="deepseek-v4-pro",
    messages=messages,
    tools=tools,
)

message = response.choices[0].message

print(message.tool_calls[0].function.name)
# get_order

print(message.tool_calls[0].function.arguments)
# {"order_id": "ORD-10442"}

Das Modell antwortet nicht direkt mit dem Bestellstatus. Stattdessen fordert es Ihre Anwendung auf, get_order auszuführen.

Eine typische Rohantwort sieht so aus:

{
  "id": "chatcmpl-8f3a1c",
  "object": "chat.completion",
  "model": "deepseek-v4-pro",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "",
        "tool_calls": [
          {
            "id": "call_0_f1c29a44",
            "type": "function",
            "function": {
              "name": "get_order",
              "arguments": "{\"order_id\": \"ORD-10442\"}"
            }
          }
        ]
      },
      "finish_reason": "tool_calls"
    }
  ],
  "usage": {
    "prompt_tokens": 312,
    "completion_tokens": 24,
    "total_tokens": 336,
    "prompt_cache_hit_tokens": 0,
    "prompt_cache_miss_tokens": 312
  }
}

Achten Sie auf drei Details:

1. finish_reason ist "tool_calls". Ihr Loop muss jetzt Tool-Aufrufe ausführen.
2. Jeder Tool-Aufruf hat eine eindeutige id.
3. arguments ist ein JSON-String. Parsen und validieren Sie ihn, bevor Sie die Funktion aufrufen.

Schritt 4: Tool ausführen und Ergebnis zurückgeben

Führen Sie den Aufruf aus. Hängen Sie danach sowohl die Assistant-Nachricht mit tool_calls als auch die Tool-Antwort an den Verlauf an.

import json

tool_call = message.tool_calls[0]
args = json.loads(tool_call.function.arguments)

result = get_order(**args)

messages.append(message)

messages.append({
    "role": "tool",
    "tool_call_id": tool_call.id,
    "content": json.dumps(result),
})

final = client.chat.completions.create(
    model="deepseek-v4-pro",
    messages=messages,
    tools=tools,
)

print(final.choices[0].message.content)
# Ihre Bestellung ORD-10442 wurde mit DHL versandt und wird voraussichtlich
# am 15. August 2026 ankommen. Sendungsverfolgungsnummer: 4281337005.

Die Verknüpfung über tool_call_id ist strikt: Für jeden Eintrag in tool_calls muss vor dem nächsten Modellzug eine passende tool-Nachricht vorhanden sein.

Schritt 5: Vollständigen Agenten-Loop implementieren

Ein produktiver Agent führt oft mehrere Schritte aus: Bestellung suchen, Rückgaberichtlinie prüfen, E-Mail formulieren oder Daten aus mehreren Systemen zusammenführen.

Der grundlegende Loop lautet:

1. Modell aufrufen.
2. Assistant-Nachricht speichern.
3. Alle angeforderten Tools ausführen.
4. Jedes Ergebnis als tool-Nachricht anhängen.
5. Wiederholen, bis keine Tool-Aufrufe mehr vorhanden sind.

import json

TOOLS_BY_NAME = {
    "get_order": get_order,
}

def run_agent(client, messages, tools, max_rounds=10):
    """Führt das Modell aus, bis es eine finale Antwort erzeugt."""
    for _ in range(max_rounds):
        response = client.chat.completions.create(
            model="deepseek-v4-pro",
            messages=messages,
            tools=tools,
        )

        message = response.choices[0].message
        messages.append(message)

        if not message.tool_calls:
            return message.content

        for tool_call in message.tool_calls:
            fn = TOOLS_BY_NAME.get(tool_call.function.name)

            try:
                if fn is None:
                    raise ValueError(
                        f"Unbekanntes Tool: {tool_call.function.name}"
                    )

                args = json.loads(tool_call.function.arguments)
                result = fn(**args)

            except Exception as exc:
                result = {
                    "error": str(exc),
                }

            messages.append({
                "role": "tool",
                "tool_call_id": tool_call.id,
                "content": json.dumps(result),
            })

    raise RuntimeError(
        f"Agent hat nicht innerhalb von {max_rounds} Runden abgeschlossen"
    )

Die Begrenzung mit max_rounds ist wichtig. Sie verhindert Endlosschleifen und begrenzt Kosten, wenn das Modell ein fehlgeschlagenes Tool wiederholt anfordert.

Parallele Tool-Aufrufe

Bei einer Anfrage wie „Vergleiche den Status von ORD-10442 und ORD-10587“ kann V4 Pro mehrere Tool-Aufrufe in einer Antwort erzeugen:

"tool_calls": [
  {
    "id": "call_0_a7d1",
    "type": "function",
    "function": {
      "name": "get_order",
      "arguments": "{\"order_id\": \"ORD-10442\"}"
    }
  },
  {
    "id": "call_1_b3e9",
    "type": "function",
    "function": {
      "name": "get_order",
      "arguments": "{\"order_id\": \"ORD-10587\"}"
    }
  }
]

Der obige run_agent-Loop verarbeitet bereits mehrere Aufrufe. Für echte parallele Ausführung können Sie die Tool-Aufrufe beispielsweise mit asyncio.gather() bündeln, sofern Ihre Tool-Implementierungen asynchron sind.

Wichtig bleibt: Jeder tool_call benötigt eine eigene tool-Nachricht mit der passenden tool_call_id.

Dieses Modell unterscheidet sich von GPT-5.6s programmatischen Tool-Aufrufen, bei denen das Modell Orchestrierungscode in einer Sandbox schreiben kann. Bei DeepSeek bleiben Tool-Ausführung und Vertrauensgrenze in Ihrer Runtime.

Denkmodus mit Tools verwenden

V4 Pro bietet drei Denkmodi. Damit können Sie für komplexe Planungsaufgaben mehr Reasoning aktivieren und bei Routineabfragen Kosten sparen. Prüfen Sie die offizielle Dokumentation für Modusnamen und Standardwerte.

Mit aktiviertem Denken liefert die API reasoning_content zusätzlich zu den Tool-Aufrufen:

response = client.chat.completions.create(
    model="deepseek-v4-pro",
    messages=messages,
    tools=tools,
    extra_body={"thinking": {"type": "enabled"}},
)

message = response.choices[0].message

print(message.reasoning_content)
print(message.tool_calls)

Nutzen Sie reasoning_content beim Debugging, etwa um zu erkennen, warum ein Modell ein bestimmtes Tool auswählt. Entfernen Sie es jedoch, bevor Sie die Assistant-Nachricht dauerhaft in die Historie übernehmen. Reasoning wird als Ausgabe abgerechnet und kostet laut Datenblatt 0,87 $/M Tokens.

Fehlerbehandlung und Argumentvalidierung

Ein Agenten-Loop darf nicht abstürzen, weil ein Tool-Aufruf ungültiges JSON enthält oder ein Pflichtfeld fehlt. Geben Sie den Fehler stattdessen als Tool-Ergebnis an das Modell zurück.

Installieren Sie bei Bedarf jsonschema:

pip install jsonschema

Validieren Sie die Argumente vor dem Tool-Aufruf:

import json
from jsonschema import ValidationError, validate

schema = tools[0]["function"]["parameters"]

try:
    args = json.loads(tool_call.function.arguments)
    validate(instance=args, schema=schema)

    result = get_order(**args)

except (json.JSONDecodeError, ValidationError) as exc:
    result = {
        "error": f"Ungültige Argumente: {exc}",
        "hint": (
            "Rufen Sie get_order erneut mit einem order_id-String "
            "wie 'ORD-10442' auf."
        ),
    }

Das Feld hint hilft dem Modell, den nächsten Versuch gezielt zu korrigieren.

Behandeln Sie fehlerhafte Tool-Aufrufe außerdem als Sicherheitsereignisse. Ein Modell ist nur so gefährlich wie die Berechtigungen hinter dem Tool. Verwenden Sie eingeschränkte Credentials, keine universellen Admin-Schlüssel und prüfen Sie Schreiboperationen zusätzlich serverseitig. Das ist besonders relevant für API-Schlüssel mit geringsten Berechtigungen für KI-Agenten.

Tool-Aufrufe mit Apidog testen und debuggen

Jedes Tool ist letztlich ein Wrapper um eine API. Wenn der zugrunde liegende Endpunkt unklar, inkonsistent oder fehlerhaft ist, überträgt sich das direkt auf Ihren Agenten.

So integrieren Sie Apidog in Ihren Entwicklungsprozess:

1. API vor dem Tool definieren.
   
   Beschreiben Sie beispielsweise GET /orders/{order_id} im visuellen Designer von Apidog. Das Tool-Schema sollte diese API-Spezifikation widerspiegeln, damit Request-Parameter und Tool-Argumente nicht auseinanderdriften.

2. Backend früh mocken.
   
   Verwenden Sie den Mock-Server, bevor der echte Bestellservice fertig ist. So können Sie Tool-Aufrufe, Rückgaben und Agenten-Loops bereits gegen realistische Antworten testen.

3. Roh-Payloads prüfen.
   
   Senden Sie denselben messages- und tools-Body aus Apidog an https://api.deepseek.com. Prüfen Sie die rohe tool_calls-Antwort auf falsch verschachtelte properties, unerwartete Felder oder doppelt kodierte JSON-Argumente.

4. Konversationen als Regressionstests speichern.
   
   Testen Sie beispielsweise finish_reason, Tool-Namen, Argumentformate und Fehlerfälle bei jeder Schemaänderung. Wegen der in Hacker News beschriebenen Harness-Empfindlichkeit sind reale Tool-Szenarien aussagekräftiger als allgemeine Benchmarks.

Ein ausführlicheres Muster finden Sie in Einen KI-Agenten in ein Apidog-Testharness einbinden.

Apidog kostenlos herunterladen, um Mock-Server und Testszenarien für Ihre Tool-APIs einzurichten.

Kosten von Agenten-Loops und Prompt-Caching

Ein Agenten-Loop sendet den Gesprächsverlauf in jeder Runde erneut. In Runde zehn enthalten die Eingabetokens unter anderem den System-Prompt, Tool-Schemas und die Ergebnisse der neun vorherigen Runden.

Die automatische Präfix-Zwischenspeicherung von V4 Pro senkt diese Kosten erheblich:

• Cache Miss: 0,435 $/M Eingabetokens
• Cache Hit: 0,003625 $/M Eingabetokens

Das erneute Lesen einer Konversation mit 100.000 Tokens kostet ohne Cache ungefähr 0,0435 $, mit Cache ungefähr 0,0004 $. Prüfen Sie prompt_cache_hit_tokens und prompt_cache_miss_tokens im usage-Block, um die tatsächliche Cache-Nutzung zu überwachen.

Für hohe Cache-Hit-Raten:

• Verändern Sie frühere Nachrichten nicht nachträglich.
• Halten Sie das tools-Array über alle Runden byte-stabil.
• Vermeiden Sie dynamische Tool-Beschreibungen oder umsortierte Tool-Listen.
• Fügen Sie neue Informationen nur ans Ende von messages an.

Der Artikel Was Prompt-Caching ist erläutert die zugrunde liegenden Mechanismen.

deepseek-v4-flash mit 0,14 $/0,28 $ kann für einzelne Tool-Routings attraktiv sein. Bei längeren Loops mit vielen Aufrufen und möglichen Wiederholungsversuchen kann V4 Pro jedoch die robustere Standardwahl sein.

FAQ

Kosten Tool-Definitionen Tokens?

Ja. Das tools-Array wird als Eingabe bei jeder Anfrage berücksichtigt. Halten Sie es stabil, damit es nach der ersten Runde Teil des gecachten Präfixes werden kann.

Kann ich Funktionsaufrufe mit strukturierten Ausgaben kombinieren?

Ja. Ein typisches Muster ist:

1. Tools laden Zwischendaten.
2. Das Modell verarbeitet die Ergebnisse.
3. Ein strukturiertes Ausgabeschema formatiert die finale Antwort.

Dadurch muss nachgelagerter Code keine Prosa parsen.

Zusammenfassung

Funktionsaufrufe mit DeepSeek V4 Pro folgen einem einfachen, OpenAI-kompatiblen Muster:

• Tool-Schemas über tools senden.
• tool_calls empfangen.
• Argumente parsen und validieren.
• Tool ausführen.
• Ergebnis mit tool_call_id zurückgeben.
• Wiederholen, bis das Modell keine Tools mehr anfordert.

Der Agenten-Loop ist klein, aber die Qualität steht und fällt mit klaren Tool-Schemas, solider Fehlerbehandlung, restriktiven Berechtigungen und Regressionstests. Entwerfen Sie die unterstützenden APIs bewusst, mocken Sie sie früh und testen Sie reale Tool-Aufrufe in Apidog, bevor Schemaänderungen Ihren Agenten in Produktion beeinträchtigen.