IT ▾
Ottieni la chiave API

Miglior LLM per la programmazione Python: come sceglierlo e testarlo

Non esiste un unico LLM migliore per la programmazione Python, perché la risposta dipende dai tuoi task, dalle tue dimensioni del contesto e da quanto sei disposto a pagare per richiesta. Questo articolo ti fornisce i criteri, il codice funzionante per tre flussi di lavoro di codifica e un piccolo harness per confrontare i modelli sul tuo lavoro.

Aggiornato

Flussi di dati isometrici che passano attraverso un ingranaggio ed emergono come blocchi di codice impilati, per la programmazione Python con un'API LLM

Punti chiave

  • Le classifiche pubbliche sono un punto di partenza. Un test su 50 task sul tuo codebase ti dice di più.
  • Per l'uso API, controlla le dimensioni del contesto, il tool calling, la modalità JSON, le impostazioni deterministiche e il prezzo per richiesta.
  • Questa API serve un modello a pesi aperti con una finestra da 100.000 token, tool calling e modalità JSON, a $0,15 e $0,50 per 1M di token.
  • Una valutazione con 150 chiamate costa circa 5 centesimi, quindi misurare è più economico che indovinare.

Perché nessun modello è il migliore per tutti

La programmazione Python copre lavori molto diversi. Scrivere un helper di dieci righe, refactoring di un modulo da 2.000 righe, lettura di una stack trace, generazione di test, traduzione di uno script shell in Python e creazione di un tool che modifica file sono tutte attività di codifica, e un modello può essere forte in uno e mediocre in un altro. Le classifiche fanno una media su molti task e molti linguaggi. Il tuo repository, le tue regole di stile e le tue librerie sono una fetta stretta di questo panorama.

Quindi la risposta pratica alla domanda è una procedura. Decidi cosa ti serve, accorcia la lista a due o tre modelli che soddisfano i requisiti tecnici, esegui gli stessi task su ciascuno e conta quanti superano i tuoi test. Il resto di questo articolo copre i requisiti, poi mostra come fare i test contro questa API.

Un altro punto prima dei dettagli. Il servizio dietro questo sito esegue un modello a pesi aperti, gestito da un provider indipendente e ottimizzato per rispondere senza rifiuti di contenuti per l'uso adulto lecito. Non è l'API ufficiale di alcun fornitore di modelli e non ci sono affermazioni sui benchmark. Trattalo come un candidato per la tua lista e misuralo come qualsiasi altro.

I criteri rilevanti per un'API

Se chiami un modello dal codice invece di chattare con esso in un editor, alcune proprietà tecniche decidono se si adatta.

CriterioPerché è importante per il lavoro con PythonQuesta API
Finestra di contestoModuli interi, lunghe trace e output dei test devono entrare con spazio per la risposta100.000 token, prompt più completamento
Chiamata di strumentiPermette al modello di eseguire codice, test e linter, poi reagire all'outputSì: tools, tool_choice, tool_calls in streaming
Modalità JSONRevisioni, report di lint e piani di refactoring leggibili dalla macchinaSì: response_format json_object
RipetibilitàTemperature più basse e un seed fisso rendono le esecuzioni di test confrontabilitemperature, top_p, stop, seed e penalità vengono passati attraverso
StreamingTool reattivi e generazioni lungheSSE con utilizzo alla fine
PrezzoI loop degli agent reinviano il contesto molte volte$0,15 input e $0,50 output per 1M di token
RifiutiTool di sicurezza, scraper e script di red-team per sistemi di tua proprietà sono leciti ma spesso rifiutatiOttimizzato per rispondere senza rifiuti sui contenuti per uso adulto legale

La tabella non dice nulla sulla qualità del codice, perché le proprietà sopra sono fatti e la qualità è qualcosa che testi. La qualità cambia anche con il prompt. Un messaggio di sistema che fissa la versione di Python, le librerie consentite e il formato della risposta spesso conta quanto il modello.

Questa API è solo testo. Invii codice come testo nel prompt e ricevi testo indietro. Non c'è generazione di immagini, audio o video, né embeddings né fine-tuning, quindi un sistema di ricerca nel codice che ha bisogno di embeddings deve procurarseli da un'altra parte.

Flusso di lavoro 1: genera una funzione con un prompt rigoroso

Inizia dal caso più semplice: chiedi una sola funzione ed estrai il blocco di codice. Una temperatura bassa dà output stabili. Il messaggio di sistema fissa la versione della lingua e il formato della risposta, rendendo l'estrazione una regex su una riga. Ottieni una chiave dalla pagina chiave ed esportala come 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."))

Tre abitudini nel prompt aiutano qui. Indica la versione di Python, così il modello non usa sintassi non eseguibile. Dì "solo libreria standard" a meno che tu non voglia davvero pacchetti di terze parti. Chiedi una risposta breve, poiché le spiegazioni lunghe costano token di output e raramente cambiano il codice. Se il modello continua ad aggiungere testo dopo il blocco, passa una sequenza stop, oppure rimuovi tutto ciò che è esterno al blocco di codice come fa la regex.

Flusso di lavoro 2: lascia che il modello esegua e corregga il suo codice

Il salto più grande in affidabilità di solito viene dal tool calling. Invece di chiedere codice e sperare, dai al modello una funzione che esegue uno script e restituisce l'output. Scrive codice, lo esegue, legge la traceback e si corregge. I risultati dei tool tornano come messaggi con role: "tool", abbinati da 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"]),
        })

Tratta la funzione run_python con cura. Esegue il codice scritto dal modello sulla tua macchina, con i tuoi permessi. Per qualcosa di più di un esperimento gettabile, eseguilo in un container o in una macchina virtuale usa e getta, senza rete, con un limite di tempo e senza accesso alle tue credenziali. Il timeout di dieci secondi e l'output tagliato nell'esempio sono il minimo.

Il ciclo è limitato a cinque round così un modello confuso non può girare all'infinito. In pratica, la maggior parte delle funzioni semplici richiede una o due esecuzioni. Se vedi il modello che ripete la stessa chiamata fallita, aggiungi la traceback al prossimo messaggio utente a parole, o abbassa la temperatura. Tieni presente che una richiesta di chiamata di funzioni in streaming tiene il suo slot di concorrenza fino alla fine dello stream, e una chiave completa permette 8 richieste concorrenti, quindi un team che condivide una chiave dovrebbe accodare le esecuzioni degli agent.

Flusso di lavoro 3: revisione strutturata del codice con modalità JSON

Le revisioni sono utili quando uno script può leggerle. La modalità JSON forza JSON valido, e il messaggio di sistema definisce la forma. Con temperature 0 e un seed fisso, lo stesso file produce la stessa revisione in esecuzioni ripetute, il che rende i diff tra le esecuzioni significativi.

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"])

Usalo da un hook pre-commit o da un passaggio CI e stampa il risultato come annotazioni. Previsti falsi positivi e falsi negativi. Un revisore basato su modello è un secondo paio di occhi veloce e mai stanco, ma non sostituisce i test, un type checker o un linter. Esegui quelli prima e usa il modello per ciò che non possono vedere, come nomi poco chiari, casi limite mancanti e gestione degli errori che cattura le eccezioni.

La finestra di 100.000 token permette di inserire file interi e talvolta piccoli pacchetti in una singola richiesta. Il limite del corpo è 8 MB, che non raggiungerai con il codice sorgente. Se una revisione viene interrotta, controlla se hai impostato max_tokens troppo basso; il parametro è opzionale e una risposta può utilizzare ciò che rimane della finestra.

Testa i modelli sui tuoi task

Ecco un piccolo ambiente di test che fa ciò che una classifica non può fare: esegue i tuoi compiti contro i tuoi test. Ogni compito ha un prompt e un frammento di test. Lo script chiede il codice al modello più volte, aggiunge il test al codice, esegue il risultato e conta i passaggi superati. Modifica l'URL di base e il nome del modello per confrontare un altro provider nello stesso modo.

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")

Aumenta la lista dei compiti a 30 o 50 elementi presi dal lavoro reale: un bug che hai risolto il mese scorso, un parser che hai scritto, una funzione con un caso limite scomodo. Includi alcuni compiti che altri strumenti hanno rifiutato o sui quali hanno dato risposte incerte. Esegui ogni compito da tre a cinque volte, perché un singolo campione dice poco. Registra il tasso di superamento, la lunghezza media dell'output e il costo per compito, e salva i risultati in un file per poterli rieseguire dopo aver modificato i prompt. Esegui il codice generato in una sandbox, come indicato sopra.

Guarda i fallimenti, non solo la percentuale. Se la maggior parte degli errori proviene da una singola libreria, aggiungi un suggerimento al messaggio di sistema. Se derivano dal modello che inventa nomi di funzioni, fornisci le firme rilevanti nel prompt. Se derivano da input lunghi, testa un prompt più breve prima di dare la colpa al modello.

Quanto costa il lavoro di programmazione

I prezzi sono $0,15 per 1M di token di input e $0,50 per 1M di token di output, e le richieste fallite o rifiutate non vengono addebitate. Tre esempi con i calcoli:

  • Esecuzione di valutazione. 50 task x 3 campioni sono 150 chiamate. Con 400 input e 600 output token ciascuno, l'input è 60.000 token ($0,009) e l'output è 90.000 token ($0,045). Totale: $0,054.
  • Revisione file. Un file di circa 600 righe è circa 8.000 token, con una revisione da 1.200 token. L'input costa $0,0012, l'output costa $0,0006, totale $0,0018. Cinquecento revisioni costano $0,90.
  • Loop dell’agente. Una correzione con sei round che invia in totale 18.000 token di input e riceve 1.500 token di output costa $0,0027 più $0,00075, per un totale di $0,00345.

I loop degli agent dominano perché ogni round rispedisce la conversazione in crescita. Taglia l'output dei tool, come fa l'esempio, e controlli la maggior parte del conto. Le ricariche sono importi interi da $20 a $500 con +5% da $50, +10% da $100 e +15% da $200, pagati in USDT su TRC20 o USDC su Base, con credito che non scade mai. Vedi prezzi. I nuovi account possono anche richiedere $0,50 di credito di prova con un clic, che finanzia alcune esecuzioni di valutazione. Una chiave di prova permette 2 richieste concorrenti e 60 al minuto.

Quando un’altra scelta è migliore

Sii onesto sui limiti di qualsiasi singolo endpoint. Se vuoi un plugin editoriale con completamento inline, un agente di programmazione costruito dal vendor o un'integrazione stretta con gli strumenti di un cloud, un prodotto costruito per quello scopo potrebbe adattarsi meglio e dovresti verificare i loro prezzi e termini attuali. Se il tuo codice non innesca mai un rifiuto, il comportamento di rifiuto di questo modello non ti offre vantaggi e i tuoi risultati di test dovrebbero decidere. Se hai bisogno di embeddings o input immagine, ti serve un altro servizio per quelle parti. Questa API è una buona scelta quando vuoi un endpoint compatibile con OpenAI che puoi chiamare da script e strumenti, con una grande finestra, tool calling e un prezzo basso. La documentazione API elenca l'insieme completo dei parametri.

02

Domande e risposte

Questo è il modello giusto per Python?

Nessun modello singolo è il migliore per ogni compito. Questa API offre un unico modello a pesi aperti con tool calling, modalità JSON e una finestra di 100.000 token, e l'harness sopra ti permette di misurarlo contro i tuoi test.

Il modello può eseguire il mio codice Python?

Da solo, no. Definisci uno strumento, ad esempio run_python, e il tuo codice lo esegue e restituisce l’output come messaggio di strumento. Esegui in una sandbox.

Quanto grande è un codebase che entra in una richiesta?

La finestra è di 100.000 token per prompt più completamento. Questo copre molti file in una volta, ma non un intero grande repository.

Funziona con il pacchetto Python di OpenAI?

Sì. Imposta base_url sull’URL dell’API, passa la tua chiave e usa l’ID del modello uncensored.

Quanto costa un’esecuzione di test?

Un’esecuzione di 150 chiamate di codifica a 400 token di input e 600 token di output ciascuna costa circa $0,054.

La tua chiave è a un modulo di distanza

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

URL di basehttps://api.visionllmapi.com/v1

Ottieni la chiave API