Qwen3.8-27B-NVFP4

Beschreibung

„Qwen3.8-27B-NVFP4“ ist ein denses Sprachmodell von Alibaba mit 27 Milliarden Parametern und eingebautem Vision-Encoder. Bei den Mixture-of-Experts-Modellen in dieser Liste rechnet pro Token nur ein Teil des Netzes mit, hier rechnen immer alle Parameter mit. Das kostet mehr Rechenzeit, hält dafür aber mehrstufige Abläufe wie Tool-Loops und länger laufende Agenten zuverlässiger durch. Gegenüber Qwen3.6 ist das Modell vor allem beim Programmieren, bei fachlichen Aufgaben und bei langlaufenden agentischen Abläufen stärker.

Es eignet sich für und unterstützt:

• Textgenerierung innerhalb einer Chat-Completion (Text zu Text)
• Tool-Calling für agentische Workflows
• Bildverständnis (Vision)
• Thinking / Reasoning für schrittweises Problemlösen, mit drei wählbaren Reasoning-Tiefen
• Verarbeitung langer Dokumente und erweiterter Kontexte

Folgende Limitierungen gelten:

• Maximale Context-Länge: 256.000 Token
• Maximal 5 Bilder pro Anfrage
• Bilder müssen als Base64-kodierte Data-URLs übermittelt werden (keine externen URLs)
• Video verarbeitet das Modell zwar, wir bieten es über diesen Endpunkt aber nicht an

Der Thinking-Modus ist standardmäßig an, und zwar in der tiefsten Stufe, die das Modell kennt. Die günstigeren Stufen findest du unter Reasoning-Tiefe steuern, was das in Token wert ist unter Was der Standard kostet, das Abschalten unter Thinking-Modus deaktivieren. Beide Parameter gehören in chat_template_kwargs, nicht auf die oberste Ebene der Anfrage.

warnung

Eine Antwort kann leer zurückkommen, wenn max_tokens zu klein ist

Das Modell denkt vor der Antwort nach, und in der Standardtiefe xhigh kann die interne Gedankenkette allein schon mehrere hundert Token lang sein. Ist max_tokens aufgebraucht, bevor das Nachdenken fertig ist, bekommst du eine Antwort mit leerem content und finish_reason: length. Abgerechnet werden die Reasoning-Token trotzdem.

Gleicher Prompt, gleiches Bild, an diesem Modell gemessen:

Einstellung	max_tokens	Reasoning-Token	content
xhigh (Standard)	500	500	leer, finish_reason: length
xhigh (Standard)	2.000	308	vorhanden
reasoning_effort: "low"	500	149	vorhanden
enable_thinking: false	500	0	vorhanden

Lass also bei max_tokens genug Luft, senke die Reasoning-Tiefe oder schalte den Thinking-Modus für diese Anfrage ab. Bekommst du einen leeren content, schau zuerst auf finish_reason.

Nutzt du dieses Modell aus n8n heraus? Der eingebaute OpenAI Chat Model-Node kann chat_template_kwargs nicht setzen — siehe Reasoning-Modelle und Thinking-Modus für einen Workaround per Community-Node.

Reasoning-Tiefe steuern

Das Modell kennt drei Reasoning-Tiefen. Je niedriger die Tiefe, desto kürzer die Wartezeit und desto weniger Token pro Turn:

Stufe	Wofür
xhigh (Standard)	Komplexe Aufgaben, die eine gründliche Analyse brauchen
medium	Wenn Genauigkeit und Geschwindigkeit beide zählen
low	Wenn es schnell und günstig sein soll, auf Kosten einer flacheren Analyse

Andere Werte nimmt das Modell nicht an, und es achtet auf Groß- und Kleinschreibung: Low wird genauso abgewiesen wie eine unbekannte Stufe. Wenn du Code von OpenAI übernimmst, beachte, dass es minimal hier nicht gibt, nimm stattdessen low. Auf einen ungültigen Wert antwortet die API mit 400, nennt den gesendeten Wert und listet die erlaubten auf.

Python

from openai import OpenAI

client = OpenAI(
    base_url="https://llm.aihosting.mittwald.de/v1",
    api_key="sk-your-api-key-here",
)

response = client.chat.completions.create(
    model="Qwen3.8-27B-NVFP4",
    messages=[{"role": "user", "content": "Fasse diesen Changelog-Eintrag in einem Satz zusammen."}],
    temperature=1.0,
    top_p=0.95,
    max_tokens=32768,
    extra_body={
        "chat_template_kwargs": {"reasoning_effort": "low"},
    },
)

print(response.choices[0].message.content)

JavaScript

import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://llm.aihosting.mittwald.de/v1",
  apiKey: "sk-your-api-key-here",
});

const response = await client.chat.completions.create({
  model: "Qwen3.8-27B-NVFP4",
  messages: [
    {
      role: "user",
      content: "Fasse diesen Changelog-Eintrag in einem Satz zusammen.",
    },
  ],
  temperature: 1.0,
  top_p: 0.95,
  max_tokens: 32768,
  // @ts-ignore – vLLM-Erweiterung
  chat_template_kwargs: { reasoning_effort: "low" },
} as any);

console.log(response.choices[0].message.content);

PHP

<?php
// composer require openai-php/client guzzlehttp/guzzle

$client = OpenAI::factory()
    ->withBaseUri('https://llm.aihosting.mittwald.de/v1')
    ->withApiKey('sk-your-api-key-here')
    ->make();

$response = $client->chat()->create([
    'model' => 'Qwen3.8-27B-NVFP4',
    'messages' => [
        ['role' => 'user', 'content' => 'Fasse diesen Changelog-Eintrag in einem Satz zusammen.'],
    ],
    'temperature' => 1.0,
    'top_p' => 0.95,
    'max_tokens' => 32768,
    'chat_template_kwargs' => ['reasoning_effort' => 'low'],
]);

echo $response->choices[0]->message->content;

Was der Standard kostet und wann du ihn herunterdrehst

Die Standardtiefe ist die teure, und die Reasoning-Token zählen genauso auf dein monatliches Token-Kontingent wie die Antwort selbst. Die AI-Hosting-Tarife starten bei 5 Mio. Token pro Monat. In einem kleinen Tarif ist das Nachdenken also der Posten, der dein Kontingent leer zieht.

Gemessen an zwei Alltagsaufgaben, je fünf Durchläufe, Median der Reasoning-Token pro Antwort mit der Spanne über die Durchläufe:

Aufgabe	xhigh (Standard)	medium	low	Thinking aus
Einen Satz klassifizieren	308 (144–1.484)	372 (292–466)	286 (152–406)	0
Support-Antwort in vier Sätzen	235 (176–329)	236 (139–449)	252 (148–300)	0
Token pro Antwort gesamt, Median	332	368	354	54

Daraus folgen zwei Dinge, und das zweite ist das, was Geld spart:

• Bei einfachen Aufgaben kosten die drei Tiefen etwa gleich viel. So oder so zwischen 235 und 372 Reasoning-Token. Von xhigh auf low zu gehen bringt hier fast nichts.
• Das Nachdenken abzuschalten hilft. Bei der Klassifikation ging die Antwort im Median von 312 Token auf 2 zurück, bei der kurzen Support-Antwort von 351 auf 122.

Die Empfehlung nach Aufgabe:

Aufgabe	Einstellung
Klassifizieren, Routing, Extraktion, kurze Standardantworten	"enable_thinking": false
Alltagschat, Textentwürfe, Übersetzung, Zusammenfassungen	"reasoning_effort": "low"
Code über mehrere Schritte, Tool-Loops, Planung	"reasoning_effort": "medium"
Harte Analyse, kniffliges Debugging, lange Agent-Läufe	bei xhigh lassen

Noch ein Grund, xhigh nicht überall anzulassen: es ist die unberechenbarste Stufe. Bei der Klassifikation lag das Nachdenken beim identischen Prompt zwischen 144 und 1.484 Token, bei zwei identischen Anfragen also ein Faktor zehn bei den Kosten. Bei 250 Reasoning-Token pro Antwort sind 5 Mio. Token nach rund 20.000 Antworten weg, ohne dass davon ein Zeichen beim Nutzer angekommen ist.

mStudio meldet sich bei 75 Prozent des Kontingents, bei 90 Prozent zusätzlich per E-Mail.

Bei mehrstufigen Agent-Aufgaben wird die ganze Aufgabe mit einer niedrigeren Tiefe nicht automatisch schneller fertig. Die einzelnen Turns kommen zügiger zurück, aber das Modell analysiert flacher, Schritte schlagen häufiger fehl und müssen wiederholt werden. Unterm Strich kann das länger dauern und mehr Token kosten als xhigh. Miss deshalb die ganze Aufgabe und nicht einen Turn.

Bei /v1/responses steht dieselbe Steuerung nativ als Feld reasoning.effort zur Verfügung, ohne chat_template_kwargs.

Thinking-Modus deaktivieren

Python

from openai import OpenAI

client = OpenAI(
    base_url="https://llm.aihosting.mittwald.de/v1",
    api_key="sk-your-api-key-here",
)

response = client.chat.completions.create(
    model="Qwen3.8-27B-NVFP4",
    messages=[{"role": "user", "content": "Was ist 2 + 2?"}],
    temperature=0.7,
    top_p=0.8,
    presence_penalty=1.5,
    max_tokens=32768,
    extra_body={
        "chat_template_kwargs": {"enable_thinking": False},
        #                        ^^^^^^^^^^^^^^^^^^^^^^^^
        # Muss hier verschachtelt sein — enable_thinking auf Top-Level-Ebene
        # wird von der API stillschweigend ignoriert.
    },
)

print(response.choices[0].message.content)

JavaScript

import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://llm.aihosting.mittwald.de/v1",
  apiKey: "sk-your-api-key-here",
});

const response = await client.chat.completions.create({
  model: "Qwen3.8-27B-NVFP4",
  messages: [{ role: "user", content: "Was ist 2 + 2?" }],
  temperature: 0.7,
  top_p: 0.8,
  presence_penalty: 1.5,
  max_tokens: 32768,
  // @ts-ignore – vLLM-Erweiterung; muss hier verschachtelt sein, nicht enable_thinking auf Top-Level
  chat_template_kwargs: { enable_thinking: false },
} as any);

console.log(response.choices[0].message.content);

PHP

<?php
// composer require openai-php/client guzzlehttp/guzzle

$client = OpenAI::factory()
    ->withBaseUri('https://llm.aihosting.mittwald.de/v1')
    ->withApiKey('sk-your-api-key-here')
    ->make();

$response = $client->chat()->create([
    'model' => 'Qwen3.8-27B-NVFP4',
    'messages' => [
        ['role' => 'user', 'content' => 'Was ist 2 + 2?'],
    ],
    'temperature' => 0.7,
    'top_p' => 0.8,
    'presence_penalty' => 1.5,
    'max_tokens' => 32768,
    'chat_template_kwargs' => ['enable_thinking' => false],
    // Muss hier verschachtelt sein — 'enable_thinking' => false auf Top-Level-Ebene
    // wird von der API stillschweigend ignoriert.
]);

echo $response->choices[0]->message->content;

Reasoning über mehrere Turns

Standardmäßig behält das Modell die Reasoning-Blöcke aller vorherigen Nachrichten, nicht nur die der letzten. Damit bleiben Entscheidungen über einen ganzen Agent-Durchlauf hinweg stabil, und der Prefix-Cache greift öfter, was Folge-Turns schneller macht. Dafür zählt das Reasoning früherer Turns mit ins Context-Fenster.

Damit nur das Reasoning der letzten Nutzernachricht behalten wird, sende:

extra_body={"chat_template_kwargs": {"preserve_thinking": False}}

Antwort auslesen

Wenn der Thinking-Modus aktiviert ist (Standard), liefert das Modell zwei separate Felder:

Feld	Inhalt
choices[0].message.reasoning	Interne Gedankenkette (kann sehr lang sein)
choices[0].message.content	Endgültige Antwort

Ist content leer, schau zuerst auf finish_reason. Bei length ist das Token-Budget beim Nachdenken ausgegangen, wie in der Warnung weiter oben beschrieben. Bei stop hat das Modell seine Antwort in den Reasoning-Block geschrieben. Dann deaktiviere den Thinking-Modus, damit content verlässlich gefüllt ist.

print(response.choices[0].message.reasoning)          # interne Gedankenkette
print(response.choices[0].message.content)             # endgültige Antwort

Empfohlene Inferenzparameter

Das Modell hat je nach Anwendungsfall unterschiedliche empfohlene Einstellungen. Greedy-Decoding (temperature 0) sollte vermieden werden – es kann zu Leistungseinbußen und endlosen Wiederholungen führen.

Thinking-Modus (Standard)

Parameter	Wert
temperature	1.0
top_p	0.95
top_k	20
presence_penalty	0.0

Non-Thinking-Modus (enable_thinking: false)

Parameter	Wert
temperature	0.7
top_p	0.8
top_k	20
presence_penalty	1.5

Wiederholt sich das Modell endlos, erhöhe presence_penalty schrittweise bis 2.0. Hohe Werte mischen gelegentlich Sprachen und kosten etwas Qualität, gehe also nur so hoch wie nötig.

Ausgabelänge

Über max_tokens steuerst du Kosten und Wartezeit. Weil die Reasoning-Token aus demselben Budget kommen, darf der Wert hier höher liegen als bei einem Modell ohne Reasoning:

Aufgabentyp	Empfohlenes max_tokens
Standardanfragen	32.768
Komplexe Aufgaben (Mathematik, Programmierwettbewerbe)	81.920
Lange Agent-Durchläufe mit reasoning_effort: xhigh	131.072

Tipps für spezifische Aufgaben

Vision (Bild zu Text)

Für Vision-Aufgaben sollte der Thinking-Modus immer deaktiviert werden – er erhöht die Latenz, ohne das Bildverständnis zu verbessern:

extra_body={"chat_template_kwargs": {"enable_thinking": False}}

Empfohlene Parameter für Vision:

Parameter	Wert
temperature	0.7
top_p	0.8
top_k	20
max_tokens	512–2048 je nach Aufgabe

Für präzise Texterkennung (OCR) oder das Auslesen von Daten nimm stattdessen temperature=0.1. Geht es um ganze Dokumente, ist GLM-OCR das passendere Modell.

Bilder sollten vor der Base64-Kodierung auf maximal 1024 px an der längsten Seite skaliert werden – große Bilder erhöhen die Wartezeit bis zum ersten Token (TTFT) erheblich. Die erste Anfrage für ein neues Bild hat eine längere TTFT, während der Bild-Encoder aufwärmt; nachfolgende Anfragen mit demselben Bild profitieren vom Caching. Fertige Hilfsfunktionen sind in den Python-Beispielen und JavaScript-Beispielen verfügbar.

In eine Anfrage passen höchstens 5 Bilder. Hast du mehr, teile sie auf mehrere Anfragen auf.

Mathematikaufgaben

Für beste Ergebnisse bei mathematischen Aufgaben füge folgende Anweisung an deinen Prompt an:

Please reason step by step, and put your final answer within \boxed{}.

Multiple-Choice-Fragen

Für konsistente, parsierbare Ausgaben bei Multiple-Choice-Aufgaben füge Folgendes an deinen Prompt an:

Please show your choice in the 'answer' field with only the choice letter, e.g., 'answer': 'C'.

Wechsel von Qwen3.6-35B-A3B-FP8

Beide Modelle stehen unter Apache 2.0, kosten pro Token dasselbe und unterstützen denselben Context von 256.000 Token. Der Wechsel ist deshalb im Kern ein anderer Wert bei model. Vier Dinge verhalten sich anders:

	Qwen3.6-35B-A3B-FP8	Qwen3.8-27B-NVFP4
Thinking	an oder aus	an oder aus, dazu drei Tiefen über reasoning_effort
Standardtiefe	eine feste Tiefe	xhigh, die tiefste. Rechne mit mehr Reasoning-Token pro Antwort
presence_penalty im Thinking-Modus	1.5	0.0
Reasoning früherer Turns	fällt weg	bleibt erhalten, siehe Reasoning über mehrere Turns

Wenn du eine laufende Integration migrierst:

1. Setze model auf Qwen3.8-27B-NVFP4.
2. Nimm presence_penalty im Thinking-Modus auf 0.0 herunter, oder lass den Parameter weg und arbeite mit dem Standard.
3. Erhöhe max_tokens, oder setze reasoning_effort auf medium oder low. An der tieferen Standardstufe merkt man bei den meisten Migrationen den Unterschied zuerst, entweder an höheren Token-Rechnungen oder an leeren Antworten.
4. Schickt deine Integration lange Verläufe, prüfe deinen Context-Verbrauch. Die erhaltenen Reasoning-Blöcke zählen mit. Mit preserve_thinking: false bekommst du das alte Verhalten zurück.

Sonst bleibt alles gleich: dieselbe Verschachtelung in chat_template_kwargs, dieselben Base64-Data-URLs für Bilder, dasselbe Format für Tool-Calling.

Nutzungsbedingungen und Lizenzhinweise

Es gelten die allgemeinen Nutzungsbedingungen. Das Modell wird von Alibaba unter der Apache 2.0-Lizenz angeboten, eine Weiternutzung der generierten Inhalte unterliegt keiner zusätzlichen Restriktion.