So verwendest du deepseek-v4-flash-vision-exp über die hiapi API: curl, Python und eine funktionierende Anfrage

deepseek-v4-flash-vision-exp ist ein Text- und Vision-Modell mit Reasoning-Fähigkeit auf hiapi, das über den standardmäßigen OpenAI-kompatiblen Endpunkt erreichbar ist: POST /v1/chat/completions. Es kann gleichzeitig Bilder und Text lesen, unterstützt den JSON-Modus sowie Funktions-/Tool-Aufrufe und bietet Streaming-Ausgabe – all das über dieselbe Anfragestruktur wie bei jedem anderen hiapi-Chat-Modell. Dieser Leitfaden führt dich durch eine funktionierende Anfrage, ein Verhalten, in das man leicht hineintappt (das Modell denkt zuerst nach und antwortet dann, und der Denkprozess verbraucht dein Token-Budget) sowie durch Produktionspraktiken, die du vor dem Livegang kennen solltest.

Was du baust

Ein Skript, das eine Eingabeaufforderung an deepseek-v4-flash-vision-exp sendet – optional mit einem Bild – und die eigentliche Antwort liest, nicht nur seine interne Denkspur.

Voraussetzungen: Ein hiapi-API-Schlüssel. Hol ihn dir aus der Konsole – jede der folgenden Anfragen erfordert ihn im Authorization-Header.

Minimales funktionierendes Beispiel

curl

curl -s -X POST "https://api.hiapi.ai/v1/chat/completions" \
  -H "Authorization: Bearer sk-your-api-key" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-v4-flash-vision-exp",
    "messages": [
      { "role": "user", "content": "Say OK and nothing else." }
    ],
    "max_tokens": 200
  }'

Die gekürzte Antwort sieht so aus:

{
  "choices": [
    {
      "finish_reason": "stop",
      "message": {
        "role": "assistant",
        "content": "OK",
        "reasoning_content": "We need to respond exactly \"OK\" and nothing else. ..."
      }
    }
  ],
  "usage": {
    "completion_tokens": 37,
    "completion_tokens_details": { "reasoning_tokens": 34 },
    "prompt_tokens": 89,
    "total_tokens": 126
  }
}

Zwei Felder sind hier wichtig: message.content ist die eigentliche Antwort, während message.reasoning_content die interne Gedankenkette des Modells ist, bevor es diese Antwort festlegt. usage.completion_tokens_details.reasoning_tokens sagt dir, wie viel des max_tokens-Budgets der Denkprozess verbraucht hat – in diesem einfachen Beispiel wurden 34 von 37 Completion-Tokens für das Reasoning verwendet, bevor das Modell „OK“ schrieb.

Das ist die Falle: Setzt du max_tokens zu niedrig, kann das Modell das gesamte Budget für das Reasoning verbrauchen, sodass content null ist und finish_reason "length" lautet. Dieselbe Anfrage mit max_tokens: 10 liefert content: null – das Modell dachte beim Erreichen des Limits noch nach. Gib diesem Modell ausreichend Spielraum: mindestens 150–300 Token für kurze Antworten, mehr für Inhalte, die echte Reasoning-Tiefe erfordern.

Python

import requests

resp = requests.post(
    "https://api.hiapi.ai/v1/chat/completions",
    headers={
        "Authorization": "Bearer sk-your-api-key",
        "Content-Type": "application/json",
    },
    json={
        "model": "deepseek-v4-flash-vision-exp",
        "messages": [
            {"role": "user", "content": "Say OK and nothing else."},
        ],
        "max_tokens": 200,
    },
    timeout=60,
)
resp.raise_for_status()
message = resp.json()["choices"][0]["message"]
print(message["content"])

Visuelle Eingaben

Du kannst Bilder neben Text übergeben, indem du content auf ein Array typisierter Segmente setzt – image_url akzeptiert jede öffentlich zugängliche Bild-URL:

curl -s -X POST "https://api.hiapi.ai/v1/chat/completions" \
  -H "Authorization: Bearer sk-your-api-key" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-v4-flash-vision-exp",
    "messages": [
      {
        "role": "user",
        "content": [
          { "type": "text", "text": "What color is the dominant background color of this image? One word." },
          { "type": "image_url", "image_url": { "url": "https://example.com/photo.jpg" } }
        ]
      }
    ],
    "max_tokens": 200
  }'

Bei einem echten Testbild gab das Modell "Beige" zurück, und reasoning_content zeigte, dass es vor der Ein-Wort-Antwort zunächst eine visuelle Beschreibung durchlief – dasselbe Muster „erst denken, dann antworten“ wie bei reinen Textanfragen, nur auf Basis des Bildes.

JSON-Modus und Tool-Aufrufe

Strukturierte JSON-Ausgabe – füge response_format: {"type": "json_object"} hinzu und erwähne JSON in der Eingabeaufforderung:

{
  "model": "deepseek-v4-flash-vision-exp",
  "messages": [
    { "role": "user", "content": "Return a JSON object with keys name and age for a fictional person." }
  ],
  "response_format": { "type": "json_object" },
  "max_tokens": 300
}

message.content wird als parsebarer JSON-String zurückgegeben ({"name": "Alex Doe", "age": 30}), während reasoning_content weiterhin den Entwurf des Modells enthält – parse nur content, niemals reasoning_content.

Funktions-/Tool-Aufrufe – übergib ein standardmäßiges tools-Array im OpenAI-Stil:

{
  "model": "deepseek-v4-flash-vision-exp",
  "messages": [
    { "role": "user", "content": "What is the weather in Tokyo right now? Use the get_weather tool." }
  ],
  "tools": [
    {
      "type": "function",
      "function": {
        "name": "get_weather",
        "description": "Get current weather for a city",
        "parameters": {
          "type": "object",
          "properties": { "city": { "type": "string" } },
          "required": ["city"]
        }
      }
    }
  ],
  "max_tokens": 300
}

Das Modell antwortet mit finish_reason: "tool_calls" und einem tool_calls-Array (enthält function.name, function.arguments als JSON-String und die call_id, die du in der Folgerunde zurückgibst) – der standardmäßige OpenAI-Funktionsaufruf-Zyklus funktioniert ohne Änderungen.

Hinweise für den Produktivbetrieb

• Reserviere das max_tokens-Budget für das Reasoning, nicht nur für die Antwort. Dies ist ein Reasoning-Modell – jede Antwort enthält vor dem endgültigen content einen reasoning_content-Prozess, und beide verbrauchen aus demselben max_tokens-Pool. Prüfe in frühen Tests usage.completion_tokens_details.reasoning_tokens, kalibriere ein sicheres Limit für deine Eingabeaufforderungen und prüfe stets finish_reason – "length" mit content null bedeutet, dass du mitten im Denken abgeschnitten wurdest und keine echte Antwort erhalten hast.
• Streaming-Ausgabe funktioniert über stream: true. Anders als einige Reasoning-Modelle auf hiapi, die Streaming erzwingen, unterstützt dieses Modell beide Modi. Im Streaming-Modus treffen reasoning_content und content als getrennte Delta-Felder im selben Chunk-Stream ein – wenn du „Denken“ und „Antwort“ als unterschiedliche UI-Zustände anzeigen möchtest, puffere sie getrennt.
• Authentifizierungsfehler werden klar zurückgegeben. Ein falscher oder widerrufener Schlüssel liefert HTTP 401 mit "code": "permission_denied" und einer request_id im Fehlerkörper. Verzweige anhand des code-Feldes statt durch Abgleich von Meldungsstrings und gib die request_id an, wenn du den Support kontaktierst.
• Zeige reasoning_content nicht als Antwort an Endnutzer. Es ist unstrukturierter Entwurf, nicht die endgültige Antwort – insbesondere im JSON-Modus oder bei Tool-Aufrufen ist nur content (oder tool_calls) für die maschinelle Verarbeitung bestimmt.
• Visuelle Eingaben akzeptieren öffentliche URLs, nicht Inline-base64. image_url.url muss von den Servern von hiapi abrufbar sein; hoste das Bild selbst oder verwende eine URL, die du kontrollierst, bevor du die Anfrage sendest.

Weiterführende Lektüre

• deepseek-v4-flash-vision-exp Modellseite – vollständige Parameterreferenz und Live-Preise
• hiapi API-Dokumentation – Authentifizierung, weitere Modellfamilien und vollständige Endpunktliste
• hiapi Preise – Token-Tarife für deepseek-v4-flash-vision-exp und alle anderen Modelle
• gpt-6-astra API-Leitfaden – ein zweites Reasoning-Modell auf hiapi mit einer anderen Integrationsform (nur Streaming, Responses API), das einen Vergleich wert ist

Häufig gestellte Fragen

Unterstützt deepseek-v4-flash-vision-exp visuelle Eingaben? Ja. Sende ein Array-förmiges content, das ein text-Segment und ein oder mehrere image_url-Segmente enthält, die jeweils auf eine öffentlich zugängliche Bild-URL verweisen. Das Modell denkt wie bei Text zuerst über das Bild nach und antwortet dann.

Warum ist message.content in meiner Antwort null? Dein max_tokens ist zu niedrig, und der Denkprozess des Modells hat das gesamte Budget verbraucht, bevor es die Antwort schreiben konnte. Prüfe finish_reason – "length" mit content: null ist genau dieser Fall; erhöhe max_tokens und versuche es erneut.

Unterstützt es den JSON-Modus? Ja, über response_format: {"type": "json_object"}. Das JSON landet als String in message.content und muss von dir selbst geparst werden; reasoning_content gehört nicht zur strukturierten Ausgabe und sollte in diesem Szenario ignoriert werden.

Unterstützt es Funktions-/Tool-Aufrufe? Ja, unter Verwendung des standardmäßigen tools-Array-Formats von OpenAI. Eine Antwort, die ein Tool auslöst, gibt finish_reason: "tool_calls" sowie ein tool_calls-Array mit Funktionsname und Argumenten zurück.

Kann ich Antworten gestreamt empfangen? Ja – setze "stream": true und konsumiere die chat.completion.chunk-Events. content und reasoning_content werden beide als getrennte Delta-Felder innerhalb desselben Chunks gestreamt.

Wie sieht ein Authentifizierungsfehler aus? HTTP 401 mit einem JSON-Antwortkörper, der "type": "hiapi_error", "code": "permission_denied", eine für Menschen lesbare message und eine request_id enthält, die du dem Support geben kannst (falls das Problem weiterhin besteht).