- Wann Qwen3 Coder Next für Coding-Agenten verwenden
- Modell-ID, Endpunkt, Preise und Limits
- Schritt 1: Einen Novita AI API-Schlüssel holen
- Schritt 2: Eine erste Codierungsanfrage senden
- Schritt 3: Qwen3 Coder Next in einer Agentenschleife verwenden
- Schritt 4: Strukturierte Ausgabe für Agentenentscheidungen hinzufügen
- Schritt 5: Kontext, Ausgabe und Kosten planen
- Fehlerbehebung
- FAQ
- Verwandte Qwen Coding-Anleitungen
Qwen3 Coder Next ist auf Novita AI als serverloses Textmodell für Coding-Agent-Workflows verfügbar, die langes Kontextverständnis von Code, strukturierte Ausgaben und funktionsaufrufähnliche Tool-Koordination über eine Chat-Completions-API benötigen. Verwende die verifizierte Modell-ID qwen/qwen3-coder-next mit dem OpenAI-kompatiblen Endpunkt POST https://api.novita.ai/openai/v1/chat/completions, wenn du ein codierungsorientiertes Modell in einer Agentenschleife einsetzen möchtest, ohne die Modell-Hosting-Infrastruktur selbst verwalten zu müssen.
Wenn du zuerst einen breiteren Überblick über den Launch und die Modellpositionierung suchst, lies Qwen3-Coder-Next auf Novita AI. Wenn dein unmittelbares Ziel darin besteht, dasselbe Modell in ein Anthropic-kompatibles Tool einzubinden, verwende die Begleitanleitung für Qwen3-Coder-Next in Claude Code.
Wann Qwen3 Coder Next für Coding-Agenten verwenden
Setze Qwen3 Coder Next ein, wenn deine Anwendung ein codierungsorientiertes Sprachmodell innerhalb eines kontrollierten Softwareentwicklungsworkflows benötigt: Code-Erklärung, Patch-Planung, Fehlerlokalisierung, Testfallentwurf, Refactoring-Überprüfung oder toolgestützte Repository-Inspektion.
Der wichtige Unterschied ist, dass dieser Leitfaden kein allgemeiner Modellüberblick ist. Er konzentriert sich auf ein Implementierungsmuster für Coding-Agenten:
- Sende Repository- oder Dateikontext in eine Chat-Completion-Anfrage;
- Frage das Modell nach einer begrenzten nächsten Aktion;
- Fordere optional strukturiertes JSON an, damit dein Agent entscheiden kann, ob er eine andere Datei inspizieren, einen Patch vorschlagen oder anhalten soll;
- Führe Tools in deiner eigenen Anwendungsschicht aus, nicht innerhalb des Modellaufrufs;
- Sende die Beobachtung zurück in die nächste Chat-Runde.
Der Katalog von Novita AI beschreibt Qwen3 Coder Next als Text-in-Text-out-LLM mit serverloser Verfügbarkeit, Funktionsaufruf-Unterstützung, strukturierter Ausgabe und langem Kontext. Das sind die Aspekte, die für Coding-Agenten wichtig sind: Das Modell kann toolaufrufähnliche Anweisungen und strukturierte Entscheidungen erstellen, während deine Anwendung für Dateisystemzugriff, Befehlsausführung, Repository-Änderungen und Freigabeschritte zuständig bleibt.
Vermeide es, das Modell so zu behandeln, als würde es direkt selbstständig ein Repository bearbeiten. Ein Coding-Agent benötigt umgebenden Code, der Kontext vorbereitet, Ausgaben validiert, Tools ausführt, Patches anwendet und Ergebnisse protokolliert. Qwen3 Coder Next liefert den Sprachmodell-Schritt in dieser Schleife.
Modell-ID, Endpunkt, Preise und Limits
Die verifizierte Novita AI Modell-ID ist qwen/qwen3-coder-next.
| Feld | Verifizierter Wert |
|---|---|
| Anzeigename | Qwen3 Coder Next |
| Modell-ID | qwen/qwen3-coder-next |
| Eingabe-Modalität | Text |
| Ausgabe-Modalität | Text |
| Endpunktfamilie | chat/completions, anthropic |
| OpenAI-kompatibler Endpunkt | POST https://api.novita.ai/openai/v1/chat/completions |
| Kontextgröße | 262.144 Token |
| Maximale Ausgabetoken | 65.536 Token |
| Gelisteter Eingabepreis | 0,20 $ pro 1 M Token |
| Gelisteter Ausgabepreis | 1,50 $ pro 1 M Token |
| Gelistete Funktionen | Funktionsaufruf, strukturierte Ausgaben, serverlos |
| Gelistete RPM bei T1-Kontingent | 30 RPM |
Preise, Ratenbegrenzungen und Verfügbarkeit können sich ändern. Überprüfe vor dem Produktions-Rollout die Novita AI Modellbibliothek und dein Konsolen-Kontingent.
Schritt 1: Einen Novita AI API-Schlüssel holen
Erstelle oder öffne dein Novita AI-Konto und generiere einen API-Schlüssel aus der Konsole. Speichere ihn als Umgebungsvariable, anstatt ihn fest in deiner Anwendung zu codieren.
export NOVITA_API_KEY="your_api_key_here"
Für die lokale Entwicklung verwende dein Shell-Profil, einen .env-Lader oder einen Secret-Manager. Für die Produktion injiziere den Schlüssel über das Secret-System deiner Bereitstellungsplattform und halte ihn von Logs, clientseitigem Code und Repository-Verlauf fern.
Schritt 2: Eine erste Codierungsanfrage senden
Beginne mit der kleinsten sinnvollen Anfrage: eine Systemnachricht, die die Rolle des Assistenten einschränkt, plus eine Benutzernachricht mit einem kurzen Codebeispiel und einer spezifischen Codierungsaufgabe.
curl https://api.novita.ai/openai/v1/chat/completions \
-H "Authorization: Bearer $NOVITA_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "qwen/qwen3-coder-next",
"messages": [
{
"role": "system",
"content": "Du bist ein Codierungsassistent. Erkläre Risiken klar und vermeide es, das Verhalten zu ändern, es sei denn, es wird darum gebeten."
},
{
"role": "user",
"content": "Überprüfe diese JavaScript-Funktion auf Randfälle:\n\nfunction divide(a, b) {\n return a / b;\n}"
}
],
"temperature": 0.2,
"max_tokens": 600
}'
Eine erfolgreiche nicht-streaming Antwort gibt ein Chat-Completion-Objekt mit einem choices-Array zurück. Lies choices[0].message.content für die Modellausgabe und usage für die Token-Abrechnung.
import os
import requests
api_key = os.environ["NOVITA_API_KEY"]
response = requests.post(
"https://api.novita.ai/openai/v1/chat/completions",
headers={
"Authorization": f"Bearer {api_key}",
"Content-Type": "application/json",
},
json={
"model": "qwen/qwen3-coder-next",
"messages": [
{
"role": "system",
"content": (
"Du bist ein Codierungsassistent. Erkläre Risiken klar "
"und halte Empfehlungen auf den bereitgestellten Code beschränkt."
),
},
{
"role": "user",
"content": (
"Überprüfe diese Python-Funktion auf Fehler:\n\n"
"def normalize(items):\n"
" return [x.strip().lower() for x in items]\n"
),
},
],
"temperature": 0.2,
"max_tokens": 600,
},
timeout=60,
)
response.raise_for_status()
data = response.json()
print(data["choices"][0]["message"]["content"])
Dieses Beispiel ist bewusst einfach gehalten. Füge Streaming, Tools oder strukturierte Ausgaben erst hinzu, nachdem die grundlegende Anfrage in deiner Umgebung funktioniert.
Schritt 3: Qwen3 Coder Next in einer Agentenschleife verwenden
Ein Coding-Agent ist eine Schleife um das Modell. Das Modell schlägt die nächste Aktion vor; deine Anwendung entscheidet, ob sie ausgeführt wird, und speist dann das Ergebnis zurück.
Für eine minimale Coding-Agentenschleife halte den Aktionsraum klein:
| Aktion | Was deine Anwendung tut |
|---|---|
inspect_file |
Liest einen erlaubten Dateipfad und gibt relevanten Inhalt zurück. |
search_code |
Durchsucht das Repository mit einer begrenzten Abfrage. |
propose_patch |
Bittet das Modell, einen Patch-Plan oder Diff zur Überprüfung zu erstellen. |
finish |
Beendet die Schleife mit einer Zusammenfassung und verbleibenden Risiken. |
Gib dem Modell keinen uneingeschränkten Shell-Zugriff. Behandle jede vorgeschlagene Aktion als Anfrage, die deine Anwendung validiert. Gute Validierung umfasst Pfad-Whitelists, maximale Dateigröße, Befehls-Whitelists (falls Befehle unterstützt werden), Timeout-Limits und menschliche Freigabe vor dem Anwenden von Änderungen.
Eine einfache Schleife kann so aussehen:
import json
import os
import requests
API_URL = "https://api.novita.ai/openai/v1/chat/completions"
MODEL = "qwen/qwen3-coder-next"
def call_model(messages):
response = requests.post(
API_URL,
headers={
"Authorization": f"Bearer {os.environ['NOVITA_API_KEY']}",
"Content-Type": "application/json",
},
json={
"model": MODEL,
"messages": messages,
"temperature": 0.1,
"max_tokens": 1200,
"response_format": {"type": "json_object"},
},
timeout=60,
)
response.raise_for_status()
return response.json()["choices"][0]["message"]["content"]
messages = [
{
"role": "system",
"content": (
"Du bist ein Planer für Coding-Agenten. Gib nur JSON mit den Schlüsseln "
"action, path, query, rationale und final_answer zurück. Erlaubte Aktionen "
"sind inspect_file, search_code, propose_patch und finish."
),
},
{
"role": "user",
"content": (
"Wir müssen herausfinden, warum normalize_user abstürzt, wenn die E-Mail fehlt. "
"Beginne mit der Auswahl des nächsten sicheren Inspektionsschritts."
),
},
]
raw = call_model(messages)
decision = json.loads(raw)
print(decision)
Dieses Beispiel verwendet den JSON-Modus, um den Anwendungs-Parser einfach zu halten. Für die Produktion validiere, dass die Antwort eine erlaubte action enthält und dass Felder wie path und query deinen Sicherheitsregeln entsprechen, bevor du etwas ausführst.
Schritt 4: Strukturierte Ausgabe für Agentenentscheidungen hinzufügen
Die Chat-Completions-API von Novita AI beinhaltet response_format, einschließlich json_object und json_schema Optionen. Qwen3 Coder Next wird in der Modellbibliothek mit Unterstützung für strukturierte Ausgaben geführt, daher sind strukturierte Entscheidungsobjekte gut für die Orchestrierung von Coding-Agenten geeignet.
Verwende strukturierte Ausgaben für Entscheidungen, die deine Software zuverlässig parsen muss:
- klassifizieren, ob eine Änderung erforderlich ist;
- einen Patch-Plan mit Dateipfaden und Risikohinweisen zurückgeben;
- entscheiden, ob mehr Kontext benötigt wird;
- eine Test-Checkliste erstellen;
- eine endgültige Zusammenfassung ausgeben, die geändertes Verhalten, Validierung und Risiken trennt.
Für strengere Validierung verwende json_schema und halte das Schema klein. Die Modellausgabe ist immer noch nicht vertrauenswürdige Eingabe für dein Programm, also validiere sie nach dem Parsen.
schema = {
"name": "coding_agent_decision",
"schema": {
"type": "object",
"properties": {
"action": {
"type": "string",
"enum": ["inspect_file", "search_code", "propose_patch", "finish"],
},
"path": {"type": "string"},
"query": {"type": "string"},
"rationale": {"type": "string"},
"risk": {"type": "string"},
},
"required": ["action", "rationale", "risk"],
"additionalProperties": False,
},
"strict": True,
}
payload = {
"model": "qwen/qwen3-coder-next",
"messages": [
{
"role": "system",
"content": "Gib die nächste Coding-Agent-Entscheidung als strukturiertes JSON zurück.",
},
{
"role": "user",
"content": "Finde den sichersten ersten Schritt zum Debuggen eines fehlschlagenden Login-Tests.",
},
],
"response_format": {
"type": "json_schema",
"json_schema": schema,
},
"temperature": 0.1,
"max_tokens": 800,
}
Verwende Funktionsaufruf, wenn deine Anwendung bereits eine Tool-Dispatch-Schicht hat. Die Novita AI API-Referenz dokumentiert ein tools-Feld, in dem Funktionen angegeben werden können. Das Modell kann JSON-Eingaben für diese Funktionen generieren, aber deine Anwendung führt die Funktion weiterhin aus und gibt Beobachtungen in einer späteren Runde zurück. Halte Tool-Beschreibungen präzise und vermeide die Offenlegung destruktiver Operationen, es sei denn, sie erfordern eine explizite Freigabe.
Schritt 5: Kontext, Ausgabe und Kosten planen
Qwen3 Coder Next hat eine gelistete Kontextgröße von 262.144 Token und eine gelistete maximale Ausgabegröße von 65.536 Token auf Novita AI. Das gibt Coding-Agenten Raum für mehrteiligen Dateikontext, aber größere Prompts erhöhen die Kosten und können die Aufmerksamkeit des Modells verwässern.
Verwende einen Retrieval-Schritt anstatt ein ganzes Repository in jede Anfrage zu packen:
- Beginne mit der Benutzeranfrage, der relevanten Fehlermeldung und einer Repository-Karte.
- Bitte das Modell, Dateien zur Inspektion auszuwählen.
- Füge nur die ausgewählten Ausschnitte oder Dateien hinzu.
- Frage nach einem begrenzten Patch-Plan, bevor du nach einem Diff fragst.
- Behalte eine kurze laufende Zusammenfassung, anstatt jede vorherige Beobachtung erneut abzuspielen.
Die Kosten basieren auf Eingabe- und Ausgabetoken. Bei den gelisteten Preisen von 0,20 $ pro 1 M Eingabetoken und 1,50 $ pro 1 M Ausgabetoken können ausführliche generierte Diffs teurer sein als eine prägnante Analyse. Setze max_tokens auf den kleinsten Wert, der zum Schritt passt. Ein Planungsschritt benötigt beispielsweise Hunderte von Token, während eine abschließende Patherklärung möglicherweise mehr benötigt.
Ratenbegrenzungen sind in einer Agentenschleife ebenfalls wichtig. Die Modellbibliothek listet das T1-Kontingent mit 30 RPM für Qwen3 Coder Next auf, wobei im Katalog höhere RPM-Stufen angezeigt werden. Gestalte deinen Agenten so, dass er 429-Antworten mit Backoff wiederholt, parallele Schleifen vermeidet, die wiederholt dieselben Dateien inspizieren, und Zusammenfassungen wo angemessen zwischenspeichert.
Fehlerbehebung
| Problem | Wahrscheinliche Ursache | Lösung |
|---|---|---|
401 oder Authentifizierungsfehler |
Fehlender, abgelaufener oder fehlerhafter API-Schlüssel | Überprüfe den Authorization: Bearer $NOVITA_API_KEY-Header und generiere den Schlüssel bei Bedarf neu. |
| Modell nicht gefunden | Falsche Modell-ID | Verwende exakt qwen/qwen3-coder-next. |
| Ausgabe ist kein gültiges JSON | Prompt oder Schema ist zu locker | Verwende response_format, senke temperature und validiere das geparste Objekt. |
| Kontext ist zu groß | Zu viele Dateien oder lange Logs in einer Anfrage | Rufe kleinere Ausschnitte ab und fasse vorherige Runden zusammen. |
| Agentenschleife ohne Fortschritt | Aktionsraum ist zu breit oder Beobachtungen wiederholen sich | Füge ein Maximaliterationslimit hinzu und fordere für jeden Schritt eine neue Begründung. |
| Unerwartete Tool-Aktion | Das Modell hat eine Aktion vorgeschlagen, die deine App nicht ausführen sollte | Erzwinge Whitelists und Freigabeschritte außerhalb des Modells. |
| Ratenbegrenzungsfehler | Zu viele parallele Aufrufe oder enge Wiederholungsschleifen | Füge exponentielles Backoff hinzu und reihe Agentenschritte in eine Warteschlange. |
FAQ
Ist Qwen3 Coder Next über die Novita AI API verfügbar?
Ja. Die Novita AI Modellbibliothek listet Qwen3 Coder Next als serverloses LLM mit der Modell-ID qwen/qwen3-coder-next.
Welchen Endpunkt sollte ich für Qwen3 Coder Next verwenden?
Verwende den OpenAI-kompatiblen Chat-Completions-Endpunkt: POST https://api.novita.ai/openai/v1/chat/completions. Der Modellkatalog listet auch eine anthropic-Endpunktfamilie auf, aber die ausführbaren Beispiele in diesem Leitfaden verwenden Chat Completions.
Wie viel kostet Qwen3 Coder Next auf Novita AI?
Der überprüfte Novita AI Katalog listet Qwen3 Coder Next zu 0,20 $ pro 1 M Eingabetoken und 1,50 $ pro 1 M Ausgabetoken. Überprüfe die Preise vor dem Launch erneut in der Modellbibliothek, da sich die Preise ändern können.
Was sind die Kontext- und Ausgabelimits?
Der überprüfte Novita AI Katalog listet eine Kontextgröße von 262.144 Token und maximale Ausgabetoken von 65.536 für Qwen3 Coder Next.
Unterstützt Qwen3 Coder Next Funktionsaufruf und strukturierte Ausgaben?
Ja. Die Novita AI Modellbibliothek listet Qwen3 Coder Next mit den Funktionen function-calling und structured-outputs. Deine Anwendung muss dennoch alle Tool-Aktionen validieren und ausführen.
Kann Qwen3 Coder Next mein Repository direkt bearbeiten?
Nein. Die API gibt Modellausgabe zurück. Das Lesen von Repositorys, die Ausführung von Befehlen, das Anwenden von Patches, Tests und Freigaben müssen in deiner eigenen Agentenlaufzeit implementiert werden.
Verwandte Qwen Coding-Anleitungen
- Qwen3-Coder-30B-A3B Instruct API auf Novita AI
- Qwen3 6/27B vs 35B-A3B auf Novita AI
- Qwen3-Coder-Next auf Novita AI: Kostengünstiges agentisches Coding in großem Maßstab
- Qwen3-Coder-Next in Claude Code verwenden: Eine 80 % günstigere Alternative
- Qwen3.7-Max auf Novita AI: Agentisches Coding für Langkontext-Workflows
- Qwen3 6/27B auf Novita AI
- Kimi K2 7B Code auf Novita AI
