Miglior LLM locale per coding Python: Locale o API ospitata?

Inizia con i tuoi vincoli, non con un nome di modello

La domanda miglior LLM locale per coding Python non ha una risposta fissa, perché i modelli cambiano rapidamente e la tua macchina è il vero limite. Prima di confrontare i nomi, annota quattro cose:

• Memoria GPU. Questo decide quali dimensioni di modello puoi eseguire.
• Esigenze di contesto. Modificare una funzione è diverso dal ragionare su un intero pacchetto.
• Regole sulla privacy. Alcuni codici non possono lasciare la tua macchina, il che è un motivo legittimo per restare locali.
• Tolleranza ai rifiuti. Strumenti di sicurezza, scraper, reverse engineering e fuzzer possono attivare i rifiuti in modelli fortemente filtrati.

Se l'operazione offline rigorosa è un requisito fondamentale, ti serve un modello che esegui tu stesso. Se non lo è, un'API ospitata elimina la questione hardware. Questo sito appartiene al secondo gruppo: è un'API ospitata compatibile con OpenAI, non un runtime locale, e vale la pena testarlo accanto alla tua configurazione locale.

Quanta memoria GPU ti serve

Una regola approssimativa per i pesi: parametri moltiplicati per byte per parametro. A precisione 16-bit sono 2 byte per parametro; a 8-bit, 1 byte; a 4-bit, circa 0,5 byte.

Dimensioni del modello	16-bit	8-bit	4-bit
7B	14 GB	7 GB	3,5 GB
14B	28 GB	14 GB	7 GB
32B	64 GB	32 GB	16 GB

Queste cifre sono solo i pesi. Hai anche bisogno di memoria per la cache del contesto, che cresce con il prompt, e per il runtime stesso. Lascia qualche gigabyte di margine, e di più se prevedi di incollare file grandi. Una quantizzazione più pesante risparmia memoria ma può costare in accuratezza, il che conta per il codice dove un singolo carattere errato rompe il programma.

Come confrontare equamente i modelli di coding

Le classifiche pubbliche misurano task di altri. Un metodo migliore richiede un'ora e usa il tuo codice.

1. Raccogli 15-20 task reali: un bug con un test fallito, una funzione da scrivere da un docstring, un refactor, una richiesta per aggiungere type hints.
2. Esegui ogni modello con lo stesso prompt, la stessa temperatura (0,2 è un buon inizio per il codice) e lo stesso seed dove supportato.
3. Valuta eseguendo i test, non leggendo la risposta. Importa moduli reali? Supera il test?
4. Annota i rifiuti separatamente. Un modello che è il 5% migliore sul codice ma rifiuta il tuo task di port scanner è peggiore per te.
5. Registra il tempo per task e, per i modelli ospitati, il costo per task.

Mantieni l'harness in un file così puoi rieseguirlo quando appare un nuovo modello. Questo riutilizzo vale più di qualsiasi singolo risultato.

Testare un'opzione ospitata sugli stessi task

Poiché l'API è compatibile con OpenAI, il tuo harness richiede solo un base URL diverso. Questo script richiede una funzione, estrae il primo blocco Python e lo esegue contro un test. L'ID del modello è 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())

Esegui lo stesso elenco di task contro il tuo modello locale e confronta i tassi di superamento. Il codice esegue l'output generato, quindi usa una directory usa e getta o un container per qualsiasi cosa oltre agli esempi di base.

Dove un modello ospitato aiuta uno sviluppatore Python

Un endpoint ospitato non è migliore in ogni caso, ma alcuni compiti si adattano bene:

• Contesto lungo. La finestra di contesto è di 100.000 token, prompt più completamento. Ci stanno un modulo di grandi dimensioni, i suoi test e una stack trace in una singola richiesta.
• Chiamata di funzioni. Puoi definire strumenti come run_tests o read_file e lasciare che il modello li chiami in un loop, con i risultati inviati come messaggi role: "tool".
• Modalità JSON. Con response_format: {"type":"json_object"} puoi ottenere una revisione del codice strutturata, ad esempio un elenco di problemi con i numeri di riga.
• Meno rifiuti sul lavoro di sicurezza. Il modello è ottimizzato per rispondere senza rifiuti di contenuto per l'uso adulto lecito, che include i test di sicurezza dei sistemi di tua proprietà o per i quali hai l'autorizzazione.

Il compromesso è chiaro: il tuo codice lascia la tua macchina e hai bisogno di una connessione di rete. I prompt non vengono utilizzati per l'addestramento, ma se la tua politica vieta l'invio del codice a terze parti, resta in locale.

Lasciare che il modello esegua i tuoi test con la chiamata di funzioni

La chiamata di funzioni trasforma una risposta singola in un loop: il modello chiede di eseguire i test, vede il fallimento e corregge il codice. Definisci un solo strumento e gestisci la chiamata tu stesso.

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:]})

Il loop è limitato a cinque round così un modello confuso non può eseguire all'infinito. Mantieni l'output dello strumento breve, perché tutto ciò che restituisci viene fatturato come input nel round successivo. Tagliarlo agli ultimi 4.000 caratteri mantiene ogni turno economico.

Quanto costa il lavoro di codifica

I prompt di codifica sono pesanti in input: incolli il codice e ricevi una risposta più breve. Prendi una richiesta di refactoring con 6.000 token di input e 1.500 token di output a $0,15 e $0,50 per 1M:

• Input: 6.000 / 1.000.000 x $0,15 = $0,0009
• Output: 1.500 / 1.000.000 x $0,50 = $0,00075
• Totale: $0,00165 per richiesta

Un migliaio di tali richieste costano $1,65. Il credito di prova da $0,50 copre circa 303 di esse, sufficienti per eseguire un benchmark di 20 attività più volte. Una GPU locale potrebbe essere più economica per richiesta a volumi elevati, ma ha un costo iniziale e non si riduce a zero quando non la stai utilizzando. La pagina prezzi ha la tabella completa.

Impostazioni pratiche per la generazione di codice

• Temperatura 0,1-0,3. Valori più bassi riducono le API inventate e i cambiamenti casuali di stile.
• Blocca un seed quando confronti i prompt, in modo che le differenze derivino dal prompt e non dal campionamento.
• Indica la versione Python e le librerie nel messaggio di sistema: "Python 3.11, solo libreria standard" elimina molta congettura.
• Chiedi i test con il codice. Un modello che scrive i propri test spesso cattura i propri errori off-by-one quando li esegui.
• Invia il traceback dell'errore, non una sua descrizione.

Per provarlo, attiva la prova nella pagina delle chiavi API, quindi segui la guida rapida. Per l'uso in stile chat, consulta la guida alla chat LLM senza censura. Il servizio è per uso lecito da parte di adulti e non genera contenuti sessuali che coinvolgono minorenni.

Errori comuni con i modelli di codifica

• Import e nomi di funzioni inventati. Esegui il codice. Un modello può descrivere un metodo di una libreria che non esiste, quindi il test è l'unico giudice.
• Sintassi obsoleta. Se hai bisogno di funzionalità moderne come il pattern matching strutturale, indica la versione Python nel prompt.
• Contesto eccessivo. Una finestra più grande non significa che dovresti incollare tutto. Invia i file che contano, più l'errore.
• Fidarsi del codice di sicurezza generato. Rivedi manualmente tutto ciò che tocca l'autenticazione, la crittografia o l'analisi degli input.
• Eseguire l'output alla cieca. Il codice generato può eliminare file o effettuare chiamate di rete. Usa un ambiente isolato.

Altre guide

• Quanto costa un LLM? Calcolo per token ed esempi
• Chat LLM Uncensored: Guida all'Integrazione e Casi d'Uso