Melhor LLM para codificação em Python: como escolher e testar um um um um um um
Não há um único melhor LLM para codificação em Python, porque a resposta depende das suas tarefas, do tamanho da janela de contexto e do que você está disposto a pagar por requisição. Este artigo oferece os critérios, código funcional para três fluxos de trabalho de codificação e um pequeno framework para comparar modelos no seu próprio trabalho.
Atualizado

Pontos principais
- Rankings públicos são um ponto de partida. Um teste de 50 tarefas na sua própria base de código diz mais.
- Para uso em API, verifique tamanho da janela de contexto, chamada de funções, modo JSON, configurações determinísticas e preço por requisição.
- Esta API oferece um único modelo de pesos abertos com janela de 100.000 tokens, chamada de funções e modo JSON, a $0,15 e $0,50 por 1M de tokens.
- Uma execução de avaliação com 150 chamadas custa cerca de 5 centavos de dólar, então medir é mais barato que adivinhar.
Nesta página
- Por que nenhum modelo é o melhor para todos
- Os critérios relevantes para uma API
- Fluxo de trabalho 1: gerar uma função com um prompt rigoroso
- Fluxo de trabalho 2: permitir que o modelo execute e corrija seu próprio código
- Fluxo de trabalho 3: revisão de código estruturada com modo JSON
- Testar modelos nas suas próprias tarefas
- Quanto custa o trabalho de codificação
- Quando outra escolha é melhor
- Mais guias
Por que nenhum modelo é o melhor para todos
A codificação em Python abrange trabalhos muito diferentes. Escrever um auxiliar de dez linhas, refatorar um módulo de 2.000 linhas, ler um stack trace, gerar testes, traduzir um script shell para Python e construir uma ferramenta que edita arquivos são todas tarefas de codificação, e um modelo pode ser forte em uma e medíocre em outra. Os rankings agregam muitas tarefas e muitos idiomas. Seu repositório, suas regras de estilo e suas bibliotecas são uma fatia estreita disso.
Então a resposta prática para a pergunta é um procedimento. Decida o que você precisa, faça uma lista curta de dois ou três modelos que atendam aos requisitos técnicos, execute as mesmas tarefas em cada um e conte quantos passam nos seus próprios testes. O restante deste artigo cobre os requisitos e mostra como fazer o teste contra esta API.
Mais um ponto antes dos detalhes. O serviço por trás deste site executa um único modelo de pesos abertos, operado por um provedor independente e ajustado para responder sem recusas de conteúdo para uso adulto lícito. Não é a API oficial de nenhum fornecedor de modelo e não há alegações de benchmark aqui. Trate-o como um candidato para sua lista curta e meça-o como qualquer outro.
Os critérios relevantes para uma API
Se você chama um modelo do código em vez de conversar com ele em um editor, algumas propriedades técnicas decidem se ele se encaixa.
| Critério | Por que importa para tarefas em Python | Esta API |
|---|---|---|
| Janela de contexto | Módulos inteiros, stack traces longos e saída de teste devem caber com espaço para a resposta | 100.000 tokens, prompt mais conclusão |
| Chamada de funções | Permite que o modelo execute código, testes e linters, e reaja à saída | Sim: ferramentas, tool_choice, tool_calls em streaming |
| Modo JSON | Revisões, relatórios de lint e planos de refatoração legíveis por máquina | Sim: response_format json_object |
| Repetibilidade | Temperatura mais baixa e uma semente fixa tornam as execuções de teste comparáveis | temperatura, top_p, stop, seed e penalidades são passados diretamente |
| Streaming | Ferramentas responsivas e gerações longas | SSE com uso no final |
| Preço | Loops de agente reenviam contexto várias vezes | $0,15 de entrada e $0,50 de saída por 1M de tokens |
| Recusas | Ferramentas de segurança, scrapers e scripts de red-team para sistemas que você possui são lícitos, mas muitas vezes recusados | Ajustado para responder sem recusas de conteúdo para uso adulto legal |
A tabela não diz nada sobre a qualidade do código, porque as propriedades acima são fatos e a qualidade é algo que você testa. A qualidade também muda com o prompt. Uma system message que define a versão do Python, as bibliotecas permitidas e o formato da resposta muitas vezes importa tanto quanto o modelo.
Esta API é apenas de texto. Você envia código como texto no prompt e recebe texto de volta. Não há geração de imagem, áudio ou vídeo, nem embeddings nem fine-tuning, então um sistema de busca de código que precisa de embeddings tem que obtê-los em outro lugar.
Fluxo de trabalho 1: gerar uma função com um prompt rigoroso
Comece com o caso mais simples: peça uma função e extraia o bloco de código. Temperatura baixa dá saída estável. A mensagem do sistema fixa a versão da linguagem e o formato da resposta, o que torna a extração uma regex de uma linha. Obtenha uma chave na página de chaves e exporte-a como LLM_API_KEY.
import os
import re
from openai import OpenAI
client = OpenAI(
base_url="https://api.visionllmapi.com/v1",
api_key=os.environ["LLM_API_KEY"],
)
def ask_for_code(task):
resp = client.chat.completions.create(
model="uncensored",
temperature=0.2,
messages=[
{
"role": "system",
"content": (
"You are a senior Python developer. Use Python 3.11, the standard "
"library only unless told otherwise, and type hints. Reply with one "
"fenced python block and at most three sentences of explanation."
),
},
{"role": "user", "content": task},
],
)
text = resp.choices[0].message.content
match = re.search(r"```(?:python)?\n(.*?)```", text, re.S)
return match.group(1) if match else text
print(ask_for_code("Write parse_duration(s) that turns '1h30m' or '45s' into seconds."))
Três hábitos de prompt ajudam aqui. Nomeie a versão do Python, para que o modelo não busque sintaxe que você não possa executar. Diga "apenas biblioteca padrão" a menos que você realmente queira pacotes de terceiros. E peça uma resposta curta, pois explicações longas custam tokens de saída e raramente alteram o código. Se o modelo continuar adicionando texto após o bloco, passe uma sequência stop ou remova tudo fora da marcação como a regex faz.
Fluxo de trabalho 2: permitir que o modelo execute e corrija seu próprio código
O maior salto na confiabilidade geralmente vem da chamada de funções. Em vez de pedir código e torcer, você dá ao modelo uma função que executa um script e retorna a saída. Ele escreve código, executa, lê o traceback e se corrige. Os resultados das ferramentas são retornados como mensagens com role: "tool", correspondidas por tool_call_id.
import json
import os
import subprocess
import sys
import tempfile
from openai import OpenAI
client = OpenAI(
base_url="https://api.visionllmapi.com/v1",
api_key=os.environ["LLM_API_KEY"],
)
def run_python(code):
with tempfile.NamedTemporaryFile("w", suffix=".py", delete=False) as f:
f.write(code)
try:
r = subprocess.run([sys.executable, f.name], capture_output=True, text=True, timeout=10)
return (r.stdout + r.stderr)[-3000:] or "(no output)"
except subprocess.TimeoutExpired:
return "timeout after 10 seconds"
tools = [{
"type": "function",
"function": {
"name": "run_python",
"description": "Run a Python script and return stdout and stderr.",
"parameters": {
"type": "object",
"properties": {"code": {"type": "string"}},
"required": ["code"],
},
},
}]
messages = [
{"role": "system", "content": "You write Python 3. Test your code with run_python before the final answer."},
{"role": "user", "content": "Write parse_duration(s) for strings like '1h30m' or '45s'. Include asserts."},
]
for _ in range(5):
resp = client.chat.completions.create(
model="uncensored",
messages=messages,
tools=tools,
tool_choice="auto",
temperature=0.2,
)
msg = resp.choices[0].message
messages.append(msg.model_dump(exclude_none=True))
if not msg.tool_calls:
print(msg.content)
break
for call in msg.tool_calls:
args = json.loads(call.function.arguments)
messages.append({
"role": "tool",
"tool_call_id": call.id,
"content": run_python(args["code"]),
})
Trate a função run_python com cuidado. Ela executa código escrito pelo modelo, na sua máquina, com suas permissões. Para qualquer coisa além de um experimento descartável, execute-a em um container ou uma máquina virtual descartável, sem rede, com limite de tempo e sem acesso às suas credenciais. O tempo limite de dez segundos e a saída reduzida no exemplo são o mínimo.
O loop é limitado a cinco rodadas para que um modelo confuso não gire para sempre. Na prática, a maioria das funções simples precisa de uma ou duas execuções. Se você vir o modelo repetindo a mesma chamada falha, adicione o traceback à próxima mensagem de usuário em palavras, ou diminua a temperatura. Lembre-se de que uma solicitação de chamada de funções em streaming mantém sua slot de concorrência até que o stream termine, e uma chave completa permite 8 requisições simultâneas, então uma equipe compartilhando uma chave deve enfileirar execuções de agente.
Fluxo de trabalho 3: revisão de código estruturada com modo JSON
Revisões são úteis quando um script pode lê-las. O modo JSON força JSON válido, e a mensagem do sistema define a forma. Com temperature 0 e uma seed fixa, o mesmo arquivo produz a mesma revisão em execuções repetidas, o que torna as diferenças entre execuções significativas.
import json
import os
from openai import OpenAI
client = OpenAI(
base_url="https://api.visionllmapi.com/v1",
api_key=os.environ["LLM_API_KEY"],
)
source = open("service.py").read()
resp = client.chat.completions.create(
model="uncensored",
response_format={"type": "json_object"},
temperature=0,
seed=7,
messages=[
{
"role": "system",
"content": (
"Review the Python file. Reply with a JSON object with the key issues, "
"a list of objects with keys line, severity (low, medium or high), "
"problem and fix. Return an empty list if you find nothing."
),
},
{"role": "user", "content": source},
],
)
for issue in json.loads(resp.choices[0].message.content)["issues"]:
print(issue["severity"], issue["line"], issue["problem"])
Use isso de um hook pre-commit ou de uma etapa de CI e imprima o resultado como anotações. Espere falsos positivos e falsos negativos. Um revisor de modelos é um segundo par de olhos que é rápido e nunca cansa, mas não substitui testes, um verificador de tipos ou um linter. Execute-os primeiro e use o modelo para o que eles não podem ver, como nomes pouco claros, casos de borda ausentes e tratamento de erros que engole exceções.
A janela de 100.000 tokens permite arquivos inteiros e às vezes pacotes pequenos em uma única requisição. O limite do corpo é 8 MB, o que você não atingirá com código fonte. Se uma revisão for cortada, verifique se você definiu max_tokens muito baixo; o parâmetro é opcional e uma conclusão pode usar o que sobra da janela.
Testar modelos nas suas próprias tarefas
Aqui está um pequeno framework que faz o que um ranking não pode: executa suas tarefas contra seus testes. Cada tarefa tem um prompt e um snippet de teste. O script pede código ao modelo várias vezes, anexa o teste ao código, executa o resultado e conta as aprovações. Altere a URL base e o nome do modelo para comparar outro provedor da mesma forma.
import os
import re
import subprocess
import sys
import tempfile
from openai import OpenAI
client = OpenAI(
base_url="https://api.visionllmapi.com/v1",
api_key=os.environ["LLM_API_KEY"],
)
TASKS = [
{
"prompt": "Write is_palindrome(s) that ignores case and non-alphanumeric characters.",
"test": "assert is_palindrome('A man, a plan, a canal: Panama')\nassert not is_palindrome('abc')",
},
{
"prompt": "Write chunk(items, n) that yields lists of at most n items.",
"test": "assert list(chunk([1,2,3,4,5], 2)) == [[1,2],[3,4],[5]]",
},
]
SAMPLES = 3
def extract(text):
m = re.search(r"```(?:python)?\n(.*?)```", text, re.S)
return m.group(1) if m else text
def passes(code, test):
with tempfile.NamedTemporaryFile("w", suffix=".py", delete=False) as f:
f.write(code + "\n\n" + test + "\n")
try:
r = subprocess.run([sys.executable, f.name], capture_output=True, timeout=10)
return r.returncode == 0
except subprocess.TimeoutExpired:
return False
total = ok = 0
for task in TASKS:
for _ in range(SAMPLES):
resp = client.chat.completions.create(
model="uncensored",
temperature=0.4,
messages=[
{"role": "system", "content": "Reply with one fenced python block and nothing else."},
{"role": "user", "content": task["prompt"]},
],
)
total += 1
ok += passes(extract(resp.choices[0].message.content), task["test"])
print(f"{ok}/{total} passed")
Aumente a lista de tarefas para 30 ou 50 itens tirados do trabalho real: um bug que você corrigiu no mês passado, um parser que você escreveu, uma função com um caso de borda complicado. Inclua algumas tarefas que outras ferramentas recusaram ou hesitaram. Execute cada tarefa de três a cinco vezes, porque uma amostra diz pouco. Registre a taxa de aprovação, o comprimento médio de saída e o custo por tarefa, e mantenha os resultados em um arquivo para que você possa reexecutar após alterar prompts. Execute o código gerado em um sandbox, conforme observado acima.
Olhe para as falhas, não apenas a porcentagem. Se a maioria das falhas vem de uma biblioteca, adicione uma dica à mensagem do sistema. Se vierem do modelo inventando nomes de funções, dê a ele as assinaturas relevantes no prompt. Se vierem de entradas longas, teste um prompt mais curto antes de culpar o modelo.
Quanto custa o trabalho de codificação
Os preços são $0,15 por 1M de tokens de entrada e $0,50 por 1M de tokens de saída, e requisições falhas ou recusadas não são cobradas. Três exemplos com a matemática:
- Execução de avaliação. 50 tarefas x 3 amostras são 150 chamadas. Com 400 de entrada e 600 de saída tokens cada, a entrada é de 60.000 tokens ($0,009) e a saída é de 90.000 tokens ($0,045). Total: $0,054.
- Revisão de arquivo. Um arquivo de cerca de 600 linhas tem aproximadamente 8.000 tokens, com uma revisão de 1.200 tokens. O custo de entrada é $0,0012, o de saída é $0,0006, totalizando $0,0018. Quinhentas revisões custam $0,90.
- Loop de agente. Uma correção com seis rodadas que envia 18.000 tokens de entrada no total e recebe 1.500 tokens de saída custa $0,0027 mais $0,00075, totalizando $0,00345.
Os loops de agente dominam porque cada rodada reenvia a conversa em crescimento. Reduza a saída das ferramentas, como mostra o exemplo, e você controla a maior parte da conta. Recarregues podem ser qualquer valor inteiro de $20 a $500, com bônus de +5% a partir de $50, +10% a partir de $100 e +15% a partir de $200, pagos em USDT na rede TRC20 ou USDC na rede Base, com crédito que nunca expira. Consulte preços. Novas contas também podem resgatar $0,50 de crédito de teste com um clique, o que financia algumas execuções de avaliação. Uma chave de teste permite 2 requisições simultâneas e 60 por minuto.
Quando outra escolha é melhor
Seja honesto sobre os limites de qualquer endpoint único. Se você quer um plugin de editor com conclusão inline, um agente de codificação construído pelo fornecedor ou integração apertada com as ferramentas de uma única nuvem, um produto feito para esse propósito pode ser mais adequado para você, e você deve verificar seus preços e termos atuais. Se o seu código nunca aciona uma recusa, o comportamento de recusa deste modelo não oferece vantagem, e os resultados do seu teste devem decidir. Se você precisa de embeddings ou entrada de imagem, você precisa de outro serviço para essas partes. Esta API é uma boa opção quando você quer um endpoint compatível com OpenAI que você pode chamar de scripts e ferramentas, com uma janela grande, chamada de funções e um preço baixo. A documentação da API lista o conjunto completo de parâmetros.
Mais guias
Perguntas e respostas
Este é o modelo certo para trabalho em Python?
Nenhum modelo único é o melhor para todas as tarefas. Esta API oferece um modelo de pesos abertos com chamada de funções, modo JSON e uma janela de 100.000 tokens, e o harness acima permite que você o meça contra seus próprios testes.
O modelo pode executar meu código Python?
Não por si só. Você define uma ferramenta, como run_python, e seu código a executa e retorna a saída como uma mensagem de ferramenta. Execute-a em uma sandbox.
Quão grande é uma base de código que cabe em uma única requisição?
A janela é de 100.000 tokens para prompt mais conclusão. Isso cobre muitos arquivos de uma vez, mas não um repositório grande inteiro.
Funciona com o pacote Python da OpenAI?
Sim. Defina base_url para a URL da API, passe sua chave e use o ID do modelo uncensored.
Quanto custa uma execução de teste?
Uma execução de 150 chamadas de codificação com 400 tokens de entrada e 600 tokens de saída cada custa cerca de $0.054.
Sua chave está a um formulário de distância
Crie uma conta, copie a chave e altere a URL base. Essa é toda a configuração.
URL basehttps://api.visionllmapi.com/v1