IT ▾
Ottieni la chiave API

qwenapis.comGuida

API Qwen3-Coder-Next: un'alternativa compatibile con OpenAI

Questo servizio non ospita un modello chiamato Qwen3-Coder-Next. Offre un modello open-weight generico dietro un endpoint compatibile con OpenAI, e questa pagina spiega quando è adatto a un agent di coding e quando no.

Aggiornato:

Braccio robotico che assembla blocchi a ciclo accanto a un cubo server, che rappresenta un loop di agent di coding

La risposta diretta su qwen3-coder-next

Se hai digitato qwen3-coder-next api in una casella di ricerca, probabilmente vuoi un endpoint a cui puntare con un agent di coding. Sii chiaro su cos’è questo sito prima di procedere: è un fornitore indipendente con un unico modello a pesi aperti, ID uncensored, ottimizzato per rispondere senza censure sui contenuti per uso adulto legale. Non è l’API ufficiale per Qwen3-Coder-Next né per alcun modello di Alibaba, e non instrada le richieste tra i vendor. Se il tuo piano dipende da quel modello esatto, il fornitore ufficiale o un host che lo elenchi con il suo nome sono la scelta giusta.

Perché scrivere questa pagina? Perché molte persone che cercano un modello per la codifica finiscono per aver bisogno della stessa infrastruttura: un endpoint chat stile OpenAI con chiamata di funzioni, una finestra ampia, limiti di richieste stabili e un costo per token prevedibile. Questa API ha tutto questo. Inoltre non rifiuta le richieste che altri assistenti scartano per motivi di policy, come scrivere uno scanner di porte per la tua rete, discutere meccaniche di exploit per un esercizio di laboratorio o generare dati di test con linguaggio grezzo. Tutto rimane nell'uso lecito, c'è un limite rigido: nessun contenuto sessuale che coinvolga minorenni.

Quello che segue è un confronto chiaro e uno schema collaudato per eseguire un loop di agent contro https://api.qwenapis.com/v1. Questa pagina non fornisce numeri di benchmark, perché qui non sono noti, e non dovresti fidarti dei punteggi di coding di chiunque più del tuo repository.

Cosa chiede un agent di coding a un'API

Togliendo i nomi dei prodotti, un agent di coding ha bisogno di sei cose dal suo endpoint modello. Ecco come questo servizio risponde a ciascuna.

EsigenzaCosa offre questa API
Chiamata di funzioni per tool di lettura, modifica ed esecuzioneSì: tools, tool_choice, streaming tool_calls, risultati come role: "tool"
Output strutturato per piani e diffModalità JSON tramite response_format
Spazio per file grandi e cronologie lunghe100.000 token, prompt più completamento
Streaming per editor liveSSE con utilizzo alla fine
Esecuzioni ripetibiliseed, temperature, top_p, stop e le penalità vengono passate
Sub-agent paralleli8 richieste parallele, 300 al minuto con una chiave completa

Altrettanto importante è ciò che manca. Non ci sono embeddings, quindi la ricerca nel codice su un indice vettoriale richiede una fonte di embedding separata. Non ci sono fine-tuning né input o output immagine. L'elenco dei modelli ha una sola voce. Se un framework agent ti permette di scegliere un modello economico per i passaggi piccoli e uno più forte per il planning, qui entrambi i ruoli useranno lo stesso modello.

La sintesi onesta è che l’infrastruttura è completa e la domanda rimasta è la qualità del modello sui tuoi task. È una domanda empirica e il credito di prova esiste per rispondervi.

Un loop di agent funzionante

Questo esempio fornisce al modello due strumenti, uno per leggere un file e uno per eseguire un comando in una directory sandbox, e itera fino a quando il modello smette di richiedere strumenti. Esegui il codice in una cartella usa e getta, poiché lo strumento di comando esegue qualsiasi cosa proponga il modello. Il punto è la struttura: aggiungi il messaggio dell’assistant, esegui ogni chiamata, aggiungi un messaggio tool per ogni chiamata, ripeti.

import json, os, subprocess
from openai import OpenAI

client = OpenAI(base_url="https://api.qwenapis.com/v1", api_key=os.environ["QWENAPIS_KEY"])

TOOLS = [
    {"type": "function", "function": {
        "name": "read_file", "description": "Read a text file from the working directory",
        "parameters": {"type": "object", "properties": {"path": {"type": "string"}}, "required": ["path"]}}},
    {"type": "function", "function": {
        "name": "run", "description": "Run a shell command and return its output",
        "parameters": {"type": "object", "properties": {"cmd": {"type": "string"}}, "required": ["cmd"]}}},
]

def call_tool(name, args):
    if name == "read_file":
        return open(args["path"], encoding="utf-8").read()[:20000]
    if name == "run":
        p = subprocess.run(args["cmd"], shell=True, capture_output=True, text=True, timeout=60)
        return (p.stdout + p.stderr)[-8000:]
    return "unknown tool"

messages = [
    {"role": "system", "content": "You fix failing tests. Use the tools, then reply with a short summary."},
    {"role": "user", "content": "Run pytest, find why it fails, and tell me the fix."},
]

for step in range(12):
    r = client.chat.completions.create(model="uncensored", messages=messages, tools=TOOLS, temperature=0.2)
    msg = r.choices[0].message
    messages.append(msg)
    if not msg.tool_calls:
        print(msg.content)
        break
    for tc in msg.tool_calls:
        try:
            out = call_tool(tc.function.name, json.loads(tc.function.arguments))
        except Exception as e:
            out = f"tool error: {e}"
        messages.append({"role": "tool", "tool_call_id": tc.id, "content": out})

Tre dettagli mantengono sano un loop come questo. Limita il numero di passaggi, come fa range(12). Tronca l’output degli strumenti, poiché ogni carattere restituito diventa input nella chiamata successiva. Usa una temperatura bassa per il lavoro di editing; 0.2 è un punto di partenza ragionevole e puoi alzarla per i passaggi di brainstorming.

Eseguire più agent senza incontrare 429

Un singolo agent è sequenziale e raramente infastidisce un limite. Una flotta di essi sì. Oltre 8 richieste simultanee l’API risponde con 429 e codice concurrency, e oltre 300 al minuto risponde con 429 e rate_limited. Anche un sovraccarico temporaneo restituisce 429, con un’intestazione Retry-After: 5. Le richieste in streaming mantengono il loro slot fino al termine dello streaming, quindi una risposta lunga in streaming conta per tutta la sua durata.

import asyncio, os
from openai import AsyncOpenAI, RateLimitError

client = AsyncOpenAI(base_url="https://api.qwenapis.com/v1", api_key=os.environ["QWENAPIS_KEY"])
gate = asyncio.Semaphore(8)

async def ask(prompt, tries=4):
    async with gate:
        for attempt in range(tries):
            try:
                r = await client.chat.completions.create(
                    model="uncensored",
                    messages=[{"role": "user", "content": prompt}],
                )
                return r.choices[0].message.content
            except RateLimitError:
                await asyncio.sleep(5 * (attempt + 1))
    return None

async def main():
    jobs = [ask(f"Write a docstring for function number {i}.") for i in range(40)]
    print(len(await asyncio.gather(*jobs)))

asyncio.run(main())

Il semaforo ti mantiene a 8 in esecuzione, e il sleep riduce il ritmo quando un 429 si insinua comunque. Poiché le richieste fallite non vengono addebitate, i retry costano zero extra. Se ti avvicini al limite, imposta il semaforo a 6 per lasciare spazio a una sessione interattiva sulla stessa chiave.

Quanto costa un'esecuzione dell'agente

Gli agent sono tariffati in base a quanto contesto reinviano, non in base a quanto codice scrivono. Prendi un’esecuzione di correzione bug di 12 passaggi. Il contesto cresce man mano che l’output degli strumenti si accumula, quindi supponi una media di 20.000 token di input e 600 token di output per passaggio.

  • Input: 12 x 20.000 = 240.000 token x $0,15 / 1M = $0,036
  • Output: 12 x 600 = 7.200 token x $0,50 / 1M = $0,0036
  • Per esecuzione: $0,0396
  • 50 esecuzioni al giorno: 50 x $0,0396 = $1,98

Le tariffe sono $0,15 per 1M token di input e $0,50 per 1M token di output, addebitate dal credito prepagato che non scade mai. Un ricarico di $20 copre circa 505 di queste esecuzioni ($20 / $0,0396). La pagina dei prezzi elenca i livelli bonus, e un’abitudine fa risparmiare più di qualsiasi livello: mantieni breve l’output degli strumenti. Dimezzando ciò che reinvii, dimezzi la voce dominante.

Usare il prompt su un modello generico per il lavoro sul codice

Un modello non venduto come modello per la codifica può comunque funzionare bene sul codice se il prompt gli dà un compito chiaro. Inserisci il linguaggio, la versione del framework e i vincoli nel messaggio di sistema, ad esempio la versione Python e la regola che non sono consentite nuove dipendenze. Chiedi una modifica alla volta. Fornisci l'output del test fallito così com'è invece di descriverlo, perché il testo di errore esatto trasporta più informazioni di una parafrasi.

Per le modifiche, chiedi un diff unificato o la sostituzione completa di una funzione, e rifiuta qualsiasi altra cosa. Il testo libero intorno al codice è difficile da applicare automaticamente. La modalità JSON aiuta quando vuoi un piano come dati, come un elenco di file con una motivazione per ogni modifica. Dopo che il modello propone una patch, esegui i test tu stesso e reinvia il risultato; non accettare l'affermazione del modello che i test passano.

Mantieni la temperatura bassa per le modifiche e alzala solo per il brainstorming. Usa un seed fisso quando confronti due versioni di prompt, in modo che le differenze derivino dal prompt e non dal rumore di campionamento. La stessa disciplina si applica a qualsiasi modello ed è ciò che trasforma una prova in un confronto equo con qualsiasi cosa tu usi oggi.

Scegliere tra questo e un modello per la codifica specifico

Usa un modello coder dedicato dal suo provider quando il tuo lavoro richiede quel modello specifico, ad esempio perché lo hai misurato sul tuo codice, perché uno standard di team lo richiede, o perché ti affidi a una funzionalità che solo quel provider offre. Controlla i prezzi e i limiti attuali prima di impegnarti.

Usa questa API quando i rifiuti sono ciò che ti rallenta, quando vuoi un unico endpoint compatibile con OpenAI che funzioni con i framework che usi già, o quando il pagamento a consumo da un piccolo saldo ti si addice meglio di un piano. Ha senso anche come secondo endpoint: invia le modifiche di routine al tuo modello abituale e instrada le richieste che un filtro delle policy rifiuta qui. Il cambio è un URL di base e un nome modello, quindi il costo del tentativo è basso.

Per provarlo, leggi la guida alla prima richiesta, crea una chiave seguendo i passaggi chiave e richiedi il credito di prova da $0,50: un clic, nessuna carta, uno per persona, valido per 7 giorni. Una chiave di prova permette 2 richieste parallele e 60 al minuto, che è sufficiente per eseguire il loop sopra una dozzina di volte. I prompt non vengono utilizzati per l’addestramento, quindi il tuo repository di test rimane escluso da qualsiasi set di addestramento.

Domande e risposte

È l'API ufficiale di Qwen3-Coder-Next?

No. È un provider indipendente con un unico modello a pesi aperti, ID uncensored. Non è un'API di un fornitore ufficiale e non offre un modello elencato con quel nome.

Supporta la chiamata di funzioni per gli agenti di coding?

Sì. Passi gli strumenti e tool_choice, ricevi tool_calls (anche in streaming) e restituisci i risultati come messaggi con role: tool.

Quanto codice entra in una singola richiesta?

La finestra di contesto è di 100.000 token per prompt e completamento insieme. Invia solo i file rilevanti per il compito e riduci l’output degli strumenti per lasciare spazio alla risposta.

Posso eseguire più agenti contemporaneamente?

Fino a 8 richieste concorrenti e 300 al minuto con una chiave completa. Una chiave di prova permette fino a 2 richieste concorrenti e 60 al minuto. Superato questo limite, ricevi un errore HTTP 429, quindi usa un semaforo.

Supporta gli embedding per la ricerca nel codice?

No. L'API copre solo le chat completion e un elenco di modelli, quindi usa una fonte di embedding separata per la ricerca vettoriale.

La tua chiave è a un modulo di distanza

Crea un account, copia la chiave, modifica l'URL di base. È tutta la configurazione.

Ottieni la chiave API