English Arabic 简体中文 繁體中文 Français Deutsch 日本語 한국어 Português Русский Español

API do Qwen3 Coder Next na Novita AI para Agentes de Codificação

Por / / LLM / 7 minutos de leitura
API do Qwen3 Coder Next na Novita AI para Agentes de Codificação
Índice
  1. Quando Usar Qwen3 Coder Next para Agentes de Codificação
  2. ID do Modelo, Endpoint, Preços e Limites
  3. Passo 1: Obter uma Chave de API da Novita AI
  4. Passo 2: Enviar uma Primeira Requisição de Codificação
  5. Passo 3: Usar Qwen3 Coder Next em um Loop de Agente
  6. Passo 4: Adicionar Saída Estruturada para Decisões do Agente
  7. Passo 5: Planejar Contexto, Saída e Custo
  8. Solução de Problemas
  9. FAQ
  10. Guias de Codificação Relacionados ao Qwen

O Qwen3 Coder Next está disponível na Novita AI como um modelo de texto serverless para workflows de agentes de codificação que precisam de compreensão de código em contexto longo, saídas estruturadas e coordenação de ferramentas no estilo function calling através de uma API de chat completions. Use o ID de modelo verificado qwen/qwen3-coder-next com o endpoint compatível com OpenAI POST https://api.novita.ai/openai/v1/chat/completions quando quiser um modelo focado em codificação em um loop de agente sem gerenciar a hospedagem do modelo.

Se quiser primeiro uma visão geral mais ampla do lançamento e posicionamento do modelo, leia Qwen3-Coder-Next na Novita AI. Se seu objetivo imediato for conectar o mesmo modelo a ferramentas compatíveis com Anthropic, use o guia complementar para Qwen3-Coder-Next no Claude Code.

Quando Usar Qwen3 Coder Next para Agentes de Codificação

Use Qwen3 Coder Next quando sua aplicação precisar de um modelo de linguagem orientado a codificação dentro de um workflow controlado de desenvolvimento de software: explicação de código, planejamento de patches, localização de bugs, elaboração de casos de teste, revisão de refatoração ou inspeção de repositório mediada por ferramentas.

A distinção importante é que este guia não é uma visão geral genérica do modelo. Ele foca em um padrão de implementação de agente de codificação:

  • enviar contexto do repositório ou arquivo em uma requisição de chat completion;
  • pedir ao modelo uma próxima ação limitada;
  • opcionalmente solicitar JSON estruturado para que seu agente possa decidir se deve inspecionar outro arquivo, propor um patch ou parar;
  • executar ferramentas em sua própria camada de aplicação, não dentro da chamada do modelo;
  • enviar a observação de volta para a próxima rodada do chat.

O catálogo da Novita AI descreve o Qwen3 Coder Next como um LLM de texto para texto com disponibilidade serverless, suporte a function calling, suporte a saídas estruturadas e contexto longo. Esses são os componentes que importam para agentes de codificação: o modelo pode produzir instruções semelhantes a chamadas de ferramenta e decisões estruturadas, enquanto sua aplicação permanece responsável pelo acesso ao sistema de arquivos, execução de comandos, alterações no repositório e portas de aprovação.

Evite tratar o modelo como se ele editasse um repositório diretamente. Um agente de codificação precisa de código ao redor que prepare o contexto, valide saídas, execute ferramentas, aplique patches e registre resultados. O Qwen3 Coder Next fornece a etapa do modelo de linguagem nesse loop.

ID do Modelo, Endpoint, Preços e Limites

O ID de modelo verificado na Novita AI é qwen/qwen3-coder-next.

Campo Valor verificado
Nome de exibição Qwen3 Coder Next
ID do modelo qwen/qwen3-coder-next
Modalidade de entrada Texto
Modalidade de saída Texto
Família de endpoints chat/completions, anthropic
Endpoint compatível com OpenAI POST https://api.novita.ai/openai/v1/chat/completions
Tamanho do contexto 262.144 tokens
Máximo de tokens de saída 65.536 tokens
Preço de entrada listado $0,20 por 1M de tokens
Preço de saída listado $1,50 por 1M de tokens
Recursos listados Function calling, saídas estruturadas, serverless
RPM listado na cota T1 30 RPM

Preços, limites de taxa e disponibilidade podem mudar. Verifique a biblioteca de modelos da Novita AI e sua cota no console antes de lançar em produção.

Passo 1: Obter uma Chave de API da Novita AI

Crie ou abra sua conta na Novita AI, então gere uma chave de API no console. Armazene-a como uma variável de ambiente em vez de codificá-la diretamente em sua aplicação.

export NOVITA_API_KEY="sua_chave_api_aqui"

Para desenvolvimento local, use seu perfil do shell, carregador .env ou gerenciador de segredos. Para produção, injete a chave através do sistema de segredos de sua plataforma de deploy e mantenha-a fora de logs, código do lado do cliente e histórico do repositório.

Passo 2: Enviar uma Primeira Requisição de Codificação

Comece com a menor requisição útil: uma mensagem de sistema que restrinja o papel do assistente, mais uma mensagem de usuário contendo um pequeno trecho de código e uma tarefa de codificação específica.

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": "Você é um assistente de codificação. Explique os riscos claramente e evite mudar o comportamento a menos que solicitado."
},
{
"role": "user",
"content": "Revise esta função JavaScript para casos de borda:\n\nfunction divide(a, b) {\n return a / b;\n}"
}
],
"temperature": 0.2,
"max_tokens": 600
}'

Uma resposta não-streaming bem-sucedida retorna um objeto de chat completion com um array choices. Leia choices[0].message.content para a saída do modelo e usage para a contagem de tokens.

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": (
                    "Você é um assistente de codificação. Explique os riscos "
                    "claramente e mantenha as recomendações dentro do código fornecido."
                ),
            },
            {
                "role": "user",
                "content": (
                    "Revise esta função Python em busca de bugs:\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"])

Este exemplo é intencionalmente simples. Adicione streaming, ferramentas ou saída estruturada somente depois que a requisição básica funcionar em seu ambiente.

Passo 3: Usar Qwen3 Coder Next em um Loop de Agente

Um agente de codificação é um loop em torno do modelo. O modelo propõe a próxima ação; sua aplicação decide se a executa e então alimenta o resultado de volta.

Para um loop de agente de codificação mínimo, mantenha o espaço de ação pequeno:

Ação O que sua aplicação faz
inspect_file Lê um caminho de arquivo permitido e retorna o conteúdo relevante.
search_code Pesquisa no repositório com uma consulta limitada.
propose_patch Pede ao modelo para produzir um plano de patch ou diff para revisão.
finish Encerra o loop com um resumo e riscos restantes.

Não dê ao modelo acesso irrestrito ao shell. Trate cada ação sugerida como uma requisição que sua aplicação valida. Uma boa validação inclui listas de permissão de caminhos, tamanho máximo de arquivo, listas de permissão de comandos se comandos forem suportados, limites de tempo limite e aprovação humana antes de aplicar alterações.

Um loop simples pode ser assim:

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": (
            "Você é um planejador de agente de codificação. Retorne apenas JSON com as chaves "
            "action, path, query, rationale e final_answer. Ações permitidas "
            "são inspect_file, search_code, propose_patch e finish."
        ),
    },
    {
        "role": "user",
        "content": (
            "Precisamos descobrir por que normalize_user falha quando o email está ausente. "
            "Comece escolhendo o próximo passo seguro de inspeção."
        ),
    },
]

raw = call_model(messages)
decision = json.loads(raw)
print(decision)

Este exemplo usa modo JSON para manter o parser da aplicação simples. Para produção, valide que a resposta contém uma action permitida e que campos como path e query correspondem às suas regras de segurança antes de executar qualquer coisa.

Passo 4: Adicionar Saída Estruturada para Decisões do Agente

A API de chat completions da Novita AI inclui response_format, com opções json_object e json_schema. O Qwen3 Coder Next está listado com suporte a saída estruturada na biblioteca de modelos, então objetos de decisão estruturados são uma boa opção para orquestração de agente de codificação.

Use saída estruturada para decisões que seu software deve analisar de forma confiável:

  • classificar se uma mudança é necessária;
  • retornar um plano de patch com caminhos de arquivo e notas de risco;
  • decidir se mais contexto é necessário;
  • produzir uma lista de verificação de teste;
  • emitir um resumo final que separe comportamento alterado, validação e riscos.

Para validação mais rigorosa, use json_schema e mantenha o esquema pequeno. A saída do modelo ainda é uma entrada não confiável para seu programa, então valide-a após a análise.

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": "Retorne a próxima decisão do agente de codificação como JSON estruturado.",
        },
        {
            "role": "user",
            "content": "Encontre o primeiro passo mais seguro para depurar um teste de login com falha.",
        },
    ],
    "response_format": {
        "type": "json_schema",
        "json_schema": schema,
    },
    "temperature": 0.1,
    "max_tokens": 800,
}

Use function calling quando sua aplicação já tiver uma camada de despacho de ferramentas. A referência da API da Novita AI documenta um campo tools onde funções podem ser fornecidas. O modelo pode gerar entradas JSON para essas funções, mas sua aplicação ainda executa a função e retorna observações em uma rodada posterior. Mantenha as descrições das ferramentas precisas e evite expor operações destrutivas a menos que exijam aprovação explícita.

Passo 5: Planejar Contexto, Saída e Custo

O Qwen3 Coder Next tem um tamanho de contexto listado de 262.144 tokens e um tamanho máximo de saída listado de 65.536 tokens na Novita AI. Isso dá aos agentes de codificação espaço para contexto de múltiplos arquivos, mas prompts maiores aumentam o custo e podem diluir a atenção do modelo.

Use uma etapa de recuperação em vez de despejar um repositório inteiro em cada requisição:

  1. Comece com a requisição do usuário, mensagem de erro relevante e mapa do repositório.
  2. Peça ao modelo para escolher arquivos para inspecionar.
  3. Adicione apenas os trechos ou arquivos selecionados.
  4. Peça um plano de patch limitado antes de pedir um diff.
  5. Mantenha um resumo curto em vez de repetir cada observação anterior.

O custo é baseado em tokens de entrada e saída. Com os preços listados de $0,20 por 1M de tokens de entrada e $1,50 por 1M de tokens de saída, diffs gerados verbose podem custar mais do que análises concisas. Defina max_tokens para o menor valor que atenda à etapa. Por exemplo, uma etapa de planejamento pode precisar de centenas de tokens, enquanto uma explicação final de patch pode precisar de mais.

Limites de taxa também importam em um loop de agente. A biblioteca de modelos lista cota T1 em 30 RPM para Qwen3 Coder Next, com níveis de RPM mais altos mostrados no catálogo. Projete seu agente para repetir respostas 429 com backoff, evitar loops paralelos que inspecionam repetidamente os mesmos arquivos e armazenar em cache resumos quando apropriado.

Solução de Problemas

Problema Causa provável Solução
401 ou falha de autenticação Chave de API ausente, expirada ou mal formatada Verifique o cabeçalho Authorization: Bearer $NOVITA_API_KEY e regenere a chave se necessário.
Modelo não encontrado ID do modelo incorreto Use qwen/qwen3-coder-next exatamente.
Saída não é JSON válido Prompt ou esquema muito solto Use response_format, abaixe temperature e valide o objeto analisado.
Contexto muito grande Muitos arquivos ou logs longos em uma requisição Recupere trechos menores e resuma as rodadas anteriores.
Agente em loop sem progresso Espaço de ação muito amplo ou observações repetidas Adicione um limite máximo de iterações e exija uma nova justificativa para cada etapa.
Ação de ferramenta inesperada O modelo sugeriu uma ação que sua aplicação não deve executar Imponha listas de permissão e portas de aprovação fora do modelo.
Erros de limite de taxa Muitas chamadas paralelas ou loops de repetição apertados Adicione backoff exponencial e coloque as etapas do agente em fila.

FAQ

O Qwen3 Coder Next está disponível através da API da Novita AI?

Sim. A biblioteca de modelos da Novita AI lista o Qwen3 Coder Next como um LLM serverless com o ID de modelo qwen/qwen3-coder-next.

Qual endpoint devo usar para o Qwen3 Coder Next?

Use o endpoint de chat completions compatível com OpenAI: POST https://api.novita.ai/openai/v1/chat/completions. O catálogo de modelos também lista uma família de endpoints anthropic, mas os exemplos executáveis neste guia usam chat completions.

Quanto custa o Qwen3 Coder Next na Novita AI?

O catálogo verificado da Novita AI lista o Qwen3 Coder Next a $0,20 por 1M de tokens de entrada e $1,50 por 1M de tokens de saída. Verifique novamente os preços na biblioteca de modelos antes do lançamento, pois os preços podem mudar.

Quais são os limites de contexto e saída?

O catálogo verificado da Novita AI lista um tamanho de contexto de 262.144 tokens e um máximo de 65.536 tokens de saída para o Qwen3 Coder Next.

O Qwen3 Coder Next suporta function calling e saídas estruturadas?

Sim. A biblioteca de modelos da Novita AI lista o Qwen3 Coder Next com recursos de function-calling e structured-outputs. Sua aplicação ainda precisa validar e executar quaisquer ações de ferramenta.

O Qwen3 Coder Next pode editar meu repositório diretamente?

Não. A API retorna a saída do modelo. Leitura de repositório, execução de comandos, aplicação de patches, testes e aprovações devem ser implementados em seu próprio runtime de agente.

Guias de Codificação Relacionados ao Qwen

Posts relacionados