Melhor LLM local para codificação Python: local ou API hospedada?

Comece com suas restrições, não com um nome de modelo

A pergunta melhor LLM local para Python não tem resposta fixa, pois modelos mudam rápido e sua máquina é o limite real. Antes de comparar nomes, anote quatro coisas:

• Memória GPU. Isso define quais tamanhos de modelo você pode executar.
• Necessidades de contexto. Editar uma função é diferente de raciocinar sobre um pacote inteiro.
• Regras de privacidade. Alguns códigos não podem sair da sua máquina, o que é motivo legítimo para ficar local.
• Tolerância a recusas. Ferramentas de segurança, scrapers, engenharia reversa e fuzzers podem acionar recusas em modelos altamente filtrados.

Se a operação offline estrita for um requisito obrigatório, você precisa de um modelo que você executa sozinho. Se não for, uma API hospedada remove a questão do hardware. Este site pertence ao segundo grupo: é uma API hospedada compatível com OpenAI, não um ambiente de execução local, e vale a pena testá-lo ao lado da sua configuração local.

Quanta memória de GPU você precisa

Uma regra aproximada para pesos: parâmetros vezes bytes por parâmetro. Na precisão de 16 bits, são 2 bytes por parâmetro; em 8 bits, 1 byte; em 4 bits, cerca de 0,5 byte.

Tamanho do modelo	16 bits	8 bits	4 bits
7B	14 GB	7 GB	3,5 GB
14B	28 GB	14 GB	7 GB
32B	64 GB	32 GB	16 GB

Esses valores são apenas para os pesos. Você também precisa de memória para o cache de contexto, que cresce com o prompt, e para o próprio tempo de execução. Deixe uma margem de alguns gigabytes e mais se planejar colar arquivos grandes. A quantização mais pesada economiza memória, mas pode custar alguma precisão, o que importa para código onde um único caractere errado quebra o programa.

Como comparar modelos de codificação de forma justa

Rankings públicos medem tarefas de outra pessoa. Um método melhor leva uma hora e usa seu próprio código.

1. Reúna 15 a 20 tarefas reais: um bug com teste falhando, uma função para escrever a partir de uma docstring, uma refatoração, uma solicitação para adicionar type hints.
2. Execute cada modelo com o mesmo prompt, a mesma temperatura (0,2 é um bom ponto de partida para código) e a mesma semente onde suportado.
3. Avalie executando os testes, não lendo a resposta. Ele importa módulos reais? Ele passa?
4. Anote as recusas separadamente. Um modelo que é 5% melhor no código, mas recusa sua tarefa de scanner de portasss, é pior para você.
5. Registre o tempo por tarefa e, para modelos hospedados, o custo por tarefa.

Mantenha o conjunto de testes em um arquivo para que você possa reexecutá-lo quando um novo modelo aparecer. Essa reutilização vale mais do que qualquer resultado único.

Testando uma opção hospedada nas mesmas tarefas

Como a API é compatível com OpenAI, sua ferramenta só precisa de uma base URL diferente. Este script pede uma função, extrai o primeiro bloco Python e o executa em um teste. O ID do modelo é uncensored.

Copyimport re
import subprocess
import tempfile
from openai import OpenAI

client = OpenAI(base_url="https://api.uncensoredlocalllm.com/v1", api_key="YOUR_API_KEY")

TASK = "Write a Python function parse_size(text) that converts '10KB' or '2 MB' to bytes."
TEST = "assert parse_size('10KB') == 10240\nassert parse_size('2 MB') == 2 * 1024 * 1024\nprint('ok')"

r = client.chat.completions.create(
    model="uncensored",
    temperature=0.2,
    seed=7,
    messages=[
        {"role": "system", "content": "You write correct Python 3. Reply with one fenced code block and no commentary."},
        {"role": "user", "content": TASK},
    ],
)
text = r.choices[0].message.content
m = re.search(r"```(?:python)?\n(.*?)```", text, re.S)
code = m.group(1) if m else text

with tempfile.NamedTemporaryFile("w", suffix=".py", delete=False) as f:
    f.write(code + "\n" + TEST)
out = subprocess.run(["python3", f.name], capture_output=True, text=True, timeout=20)
print(out.stdout.strip() or out.stderr.strip())

Execute a mesma lista de tarefas contra seu modelo local e compare as taxas de aprovação. O código executa a saída gerada, então use um diretório descartável ou um contêiner para qualquer coisa além de exemplos simples.

Onde um modelo hospedado ajuda um desenvolvedor Python

Um endpoint hospedado não é melhor em todos os casos, mas algumas tarefas se adaptam bem a ele:

• Grande contexto. A janela de contexto é de 100.000 tokens, incluindo prompt e conclusão. Isso comporta um módulo considerável, seus testes e um rastreamento de pilha em uma única requisição.
• Chamada de funções. Você pode definir ferramentas como run_tests ou read_file e permitir que o modelo as chame em loop, com os resultados enviados de volta como mensagens role: "tool".
• Modo JSON. Com response_format: {"type":"json_object"} você pode obter uma revisão de código estruturada, como uma lista de problemas com números de linha.
• Menos recusas em trabalho de segurança. O modelo é ajustado para responder sem recusas de conteúdo para uso adulto lícito, o que inclui testes de segurança de sistemas que você possui ou está autorizado a testar.

A compensação é clara: seu código sai da sua máquina e você precisa de uma conexão de rede. Os prompts não são usados para treinamento, mas se sua política proíbe enviar código para qualquer terceiro, mantenha tudo local.

Deixando o modelo executar seus testes com chamada de funções

A chamada de funções transforma uma resposta única em um loop: o modelo pede para executar os testes, vê a falha e corrige o código. Defina uma ferramenta e gerencie a chamada você mesmo.

Copyimport json
import subprocess
from openai import OpenAI

client = OpenAI(base_url="https://api.uncensoredlocalllm.com/v1", api_key="YOUR_API_KEY")

tools = [{
    "type": "function",
    "function": {
        "name": "run_tests",
        "description": "Run pytest in the project and return the output",
        "parameters": {"type": "object", "properties": {}, "required": []},
    },
}]

messages = [
    {"role": "system", "content": "You fix Python bugs. Call run_tests to check your work."},
    {"role": "user", "content": "The tests in this project fail. Run them and tell me the first error."},
]

for _ in range(5):
    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 call in msg.tool_calls:
        out = subprocess.run(["pytest", "-x", "-q"], capture_output=True, text=True)
        messages.append({"role": "tool", "tool_call_id": call.id, "content": (out.stdout + out.stderr)[-4000:]})

O loop é limitado a cinco rodadas para que um modelo confuso não execute para sempre. Mantenha a saída da ferramenta curta, porque tudo o que você retorna é cobrado como entrada na próxima rodada. Cortar para os últimos 4.000 caracteres mantém cada turno barato.

O custo para trabalho de codificação

Prompts de codificação são pesados em entrada: você cola código e recebe uma resposta mais curta. Considere uma solicitação de refatoração com 6.000 tokens de entrada e 1.500 tokens de saída a $0,15 e $0,50 por 1M:

• Entrada: 6.000 / 1.000.000 x $0,15 = $0,0009
• Saída: 1.500 / 1.000.000 x $0,50 = $0,00075
• Total: $0,00165 por requisição

Mil requisições assim custam $1,65. O crédito de teste de $0,50 cobre cerca de 303 delas, o suficiente para executar um benchmark de 20 tarefas várias vezes. Uma GPU local pode ser mais barata por requisição em alto volume, mas tem um custo inicial e não diminui para zero quando você não está usando. A página de preços tem a tabela completa.

Configurações práticas para geração de código

• Temperatura de 0,1 a 0,3. Valores mais baixos reduzem APIs inventadas e mudanças aleatórias de estilo.
• Fixe uma seed quando comparar prompts, para que as diferenças venham do prompt e não da amostragem.
• Indique a versão do Python e as bibliotecas na mensagem do sistema: "Python 3.11, apenas biblioteca padrão" remove muita suposição.
• Peça testes junto com o código. Um modelo que escreve seus próprios testes frequentemente detecta seus próprios erros off-by-one quando você os executa.
• Envie o traceback de falha, não uma descrição dele.

Para testar, resgate o crédito de teste grátis na página da chave de API e siga o guia de início rápido. Para uso estilo chat, consulte o guia de chat de LLM sem censura. O serviço é para uso adulto lícito e não gera conteúdo sexual envolvendo menores de idade.

Erros comuns com modelos de codificação

• Importações e nomes de funções inventados. Execute o código. Um modelo pode descrever um método de biblioteca que não existe, então o teste é o único juiz.
• Sintaxe desatualizada. Se você precisa de recursos modernos como correspondência de padrões estruturais, nomeie a versão do Python no prompt.
• Contexto demais. Uma janela maior não significa que você deve colar tudo. Envie os arquivos importantes, além do erro.
• Confiar no código de segurança gerado. Revise manualmente qualquer coisa que toque autenticação, cripto ou análise de entrada.
• Executar saída cegamente. Código gerado pode excluir arquivos ou fazer chamadas de rede. Use uma sandbox.

Mais guias

• Quanto custa um LLM? Matemática por token e exemplos
• Chat LLM Sem Censura: Guia de Integração e Casos de Uso