Beste lokale LLM voor Python-codering: lokaal of gehoste API?

Begin met je beperkingen, niet met een modelnaam

De vraag beste lokale llm voor python-codering heeft geen vast antwoord, omdat modellen snel veranderen en je machine de echte limiet is. Schrijf voor het vergelijken van namen vier dingen op:

• GPU-geheugen. Dit bepaalt welke modelgroottes je überhaupt kunt draaien.
• Contextbehoeften. Het bewerken van één functie verschilt van redeneren over een heel pakket.
• Privacyregels. Sommige code mag je machine niet verlaten, wat een legitieme reden is om lokaal te blijven.
• Weigeringstolerantie. Securitytooling, scrapers, reverse engineering en fuzzers kunnen weigeringen uitlokken in sterk gefilterde modellen.

Als strikt offline opereren een harde eis is, heb je een model nodig dat je zelf draait. Als dat niet zo is, verwijdert een gehoste API de hardwarevraag. Deze site behoort tot de tweede groep: het is een gehoste, OpenAI-compatibele API, geen lokale runtime, en het is de moeite waard om naast je lokale setup te testen.

Hoeveel GPU-geheugen heb ik nodig

Een ruwe regel voor gewichten: parameters keer bytes per parameter. Bij 16-bit precisie is dat 2 bytes per parameter; bij 8-bit, 1 byte; bij 4-bit, ongeveer 0,5 bytes.

Modelgrootte	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

Deze cijfers zijn alleen gewichten. Je hebt ook geheugen nodig voor de contextcache, die groeit met de prompt, en voor de runtime zelf. Laat een paar gigabytes marge, en meer als je van plan bent grote bestanden te plakken. Zwaardere kwantisering bespaart geheugen, maar kan wat nauwkeurigheid kosten, wat belangrijk is voor code waar een enkel verkeerd teken het programma breekt.

Hoe coderingsmodellen eerlijk vergelijken

Openbare ranglijsten meten taken van iemand anders. Een betere methode duurt een uur en gebruikt je eigen code.

1. Verzamel 15 tot 20 echte taken: een bug met een mislukte test, een functie om te schrijven vanuit een docstring, een refactor, een verzoek om type hints toe te voegen.
2. Voer elk model uit met dezelfde prompt, dezelfde temperatuur (0,2 is een verstandig startpunt voor code) en dezelfde seed waar ondersteuning is.
3. Beoordeel door de tests uit te voeren, niet door het antwoord te lezen. Importeert het echte modules? Slaagt het?
4. Noteer weigeringen apart. Een model dat 5% beter is in code, maar je poortscanner-taak weigert, is slechter voor jou.
5. Registreer tijd per taak en, voor gehoste modellen, kosten per taak.

Houd het harness in een bestand zodat je het kunt herdraaien wanneer er een nieuw model verschijnt. Dat hergebruik is meer waard dan enig enkel resultaat.

Een gehoste optie testen op dezelfde taken

Omdat de API OpenAI-compatibel is, heeft je harness alleen een andere basis-URL nodig. Dit script vraagt om een functie, haalt het eerste Python-blok eruit en voert het uit tegen een test. De model-ID is 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())

Voer dezelfde takenlijst uit op je lokale model en vergelijk de slaagpercentages. De code voert gegenereerde uitvoer uit, dus gebruik een tijdelijke map of een container voor alles wat verder gaat dan voorbeeldgebruik.

Waar een gehost model een Python-ontwikkelaar helpt

Een gehost endpoint is niet in elk geval beter, maar een paar taken zijn er goed voor geschikt:

• Groot contextvenster. Het venster is 100.000 tokens, prompt plus completion. Daarin passen een aanzienlijke module, de tests en een stack trace in één verzoek.
• Function calling. Je kunt tools definiëren zoals run_tests of read_file en het model laten ze in een loop aanroepen, waarbij de resultaten als role: "tool"-berichten worden teruggestuurd.
• JSON-modus. Met response_format: {"type":"json_object"} kun je een gestructureerde codereview krijgen, zoals een lijst met problemen met regelnummers.
• Minder weigeringen bij beveiligingswerk. Het model is afgestemd om te antwoorden zonder inhoudelijke weigeringen voor legaal gebruik door volwassenen, wat onder meer beveiligingstesten van systemen omvat die je bezit of geautoriseerd bent om te testen.

Het compromis is duidelijk: je code verlaat je machine en je hebt een netwerkverbinding nodig. Prompts worden niet gebruikt voor training, maar als je beleid het versturen van code naar derden verbiedt, blijf lokaal.

Het model je tests laten draaien met function calling

Function calling verandert een eenmalig antwoord in een loop: het model vraagt om het uitvoeren van de tests, ziet de fout en herstelt de code. Definieer één tool en verwerk de aanroep zelf.

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

De loop is beperkt tot vijf rondes, zodat een verward model niet oneindig door kan draaien. Houd de tooloutput kort, omdat alles wat je terugstuurt wordt gefactureerd als input in de volgende ronde. Het beperken tot de laatste 4.000 tekens houdt elke beurt goedkoop.

Wat het kost voor codeerwerk

Code-prompts zijn input-zwaar: je plakt code en krijgt een korter antwoord. Neem een refactoringverzoek met 6.000 input tokens en 1.500 output tokens tegen $0,15 en $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
• Totaal: $0,00165 per verzoek

Duizend van zulke verzoeken kosten $1,65. Het $0,50 proeftegoed dekt ongeveer 303 daarvan, genoeg om een benchmark van 20 taken meerdere keren uit te voeren. Een lokale GPU kan goedkoper zijn per verzoek bij hoge volumes, maar heeft een vaste aankoopprijs en daalt niet naar nul als je het niet gebruikt. De prijzenpagina heeft de volledige tabel.

Praktische instellingen voor codegeneratie

• Temperatuur 0,1 tot 0,3. Lagere waarden verminderen verzonnen API's en willekeurige stijlovergangen.
• Pin een seed als je prompts vergelijkt, zodat verschillen afkomstig zijn van de prompt en niet van sampling.
• Noem de Python-versie en bibliotheken in het systeembericht: "Python 3.11, alleen standaardbibliotheek" vermindert raden aanzienlijk.
• Vraag om tests met de code. Een model dat zijn eigen tests schrijft, vangt vaak eigen off-by-one-fouten op wanneer je ze uitvoert.
• Stuur de mislukte traceback, geen beschrijving ervan.

Om het te proberen, claim het proeftegoed op de API-sleutelpagina, volg daarna de quickstart. Voor chat-achtig gebruik, zie de uncensored LLM chat-gids. De service is voor legaal gebruik door volwassenen en genereert geen seksuele inhoud met minderjarigen.

Veelgemaakte fouten met code-modellen

• Verzonnen imports en functienamen. Voer de code uit. Een model kan een bibliotheekmethode beschrijven die niet bestaat, dus de test is de enige rechter.
• Verouderde syntaxis. Als je moderne functies nodig hebt zoals pattern matching, noem dan de Python-versie in de prompt.
• Te veel context. Een groter venster betekent niet dat je alles moet plakken. Stuur alleen de bestanden die ertoe doen, plus de foutmelding.
• Gegenereerde beveiligingscode blind vertrouwen. Beoordeel alles wat raakt aan authenticatie, crypto of input parsing met de hand.
• Blind gegenereerde output uitvoeren. Gegenereerde code kan bestanden verwijderen of netwerkverbindingen maken. Gebruik een sandbox.

Meer handleidingen

• Hoeveel kost een LLM? Rekenen per token, met voorbeelden
• Uncensored LLM Chat: Integratiegids & Gebruiksscenario's