Beste LLM voor Python-coderen: Hoe kies en test je er één
Er is niet één beste LLM voor Python-coderen, omdat het antwoord afhangt van je taken, de grootte van je contextvenster en wat je bereid bent per verzoek te betalen. Dit artikel geeft je de criteria, werkende code voor drie coderingsworkflows en een kleine harness om modellen te vergelijken op je eigen werk.
Bijgewerkt

Belangrijkste punten
- Publieke ranglijsten zijn een startpunt. Een test met 50 taken op je eigen codebase vertelt je meer.
- Controleer voor API-gebruik de contextgrootte, tool calling, JSON-modus, deterministische instellingen en de prijs per verzoek.
- Deze API bedient één open-weight model met een contextvenster van 100.000 tokens, tool calling en JSON-modus, tegen $0,15 en $0,50 per 1M tokens.
- Een evaluatierun van 150 oproepen kost ongeveer 5 cent, dus meten is goedkoper dan raden.
Op deze pagina
- Waarom er geen enkel model voor iedereen het beste is
- De criteria die ertoe doen voor een API
- Workflow 1: een functie genereren met een strikte prompt
- Workflow 2: het model zijn eigen code laten runnen en fixen
- Workflow 3: gestructureerde codereview met JSON-modus
- Modellen testen op je eigen taken
- Wat codeerwerk kost
- Wanneer een andere keuze beter is
- Meer handleidingen
Waarom er geen enkel model voor iedereen het beste is
Python-coderen dekt zeer verschillende taken. Een helper van tien regels schrijven, een module van 2.000 regels refactoren, een stacktrace lezen, tests genereren, een shellscript naar Python vertalen en een tool bouwen die bestanden bewerkt, zijn allemaal codering, en een model kan sterk zijn in het ene en matig in het andere. Leaderboards maken een gemiddelde over veel taken en talen. Jouw repository, je stijlregels en je bibliotheken zijn een smal deel daarvan.
Het praktische antwoord op de vraag is dus een procedure. Bepaal wat je nodig hebt, maak een korte lijst van twee of drie modellen die aan de technische eisen voldoen, voer dezelfde taken door elk model heen en tel hoeveel je eigen tests slagen. De rest van dit artikel behandelt de eisen en laat vervolgens zien hoe je dit kunt testen tegen deze API.
Nog een punt voor de details. De service achter deze site draait één open-weight model, beheerd door een onafhankelijke provider en afgestemd op antwoorden zonder inhoudelijke weigeringen voor wettelijk volwassen gebruik. Het is niet de officiële API van een modelleverancier en er zijn hier geen benchmark-claims. Beschouw het als één kandidaat voor je korte lijst en meet het zoals elk ander model.
De criteria die ertoe doen voor een API
Als je een model aanroept vanuit code in plaats van er mee te chatten in een editor, bepalen een paar technische eigenschappen of het past.
| Criterium | Waarom het ertoe doet voor Python-werk | Deze API |
|---|---|---|
| Contextvenster | Hele modules, lange tracebacks en testuitvoer moeten passen met ruimte voor het antwoord | 100.000 tokens, prompt plus voltooiing |
| Function calling | Stelt het model in staat code, tests en linters uit te voeren en te reageren op de uitvoer | Ja: tools, tool_choice, gestreamde tool_calls |
| JSON-modus | Machine-leesbare reviews, lint-rapporten en refactoring-plannen | Ja: response_format json_object |
| Reproduceerbaarheid | Een lagere temperatuur en een vaste seed maken testruns vergelijkbaar | temperature, top_p, stop, seed en penalties worden doorgegeven |
| Streaming | Responsieve tools en lange generaties | SSE met usage aan het einde |
| Prijs | Agentloops sturen context meerdere keren opnieuw | $0,15 input en $0,50 output per 1M tokens |
| Weigeringen | Security tooling, scrapers en red-team-scripts voor systemen die je eigendom zijn zijn wettelijk, maar worden vaak geweigerd | Afgestemd op antwoorden zonder inhoudsrefusies voor wettelijk volwassen gebruik |
De tabel zegt niets over de codekwaliteit, omdat de bovenstaande eigenschappen feiten zijn en kwaliteit iets is dat je test. Kwaliteit verandert ook met de prompt. Een systeembericht dat de Python-versie, de toegestane bibliotheken en het antwoordformaat vastlegt, is vaak net zo belangrijk als het model.
Deze API is alleen tekst. Je stuurt code als tekst in de prompt en krijgt tekst terug. Er is geen beeld-, audio- of video-generatie, geen embeddings en geen fine-tuning, dus een codesearch-systeem dat embeddings nodig heeft, moet ze elders ophalen.
Workflow 1: een functie genereren met een strikte prompt
Begin met het eenvoudigste geval: vraag om één functie en haal het codeblok op. Een lage temperatuur geeft stabiele output. Het systeembericht fixeert de taalversie en het antwoordformaat, wat het extraheren tot een regex van één regel maakt. Haal een sleutel op van de sleutelpagina en exporteer deze als 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."))
Drie promptgewoontes helpen hier. Noem de Python-versie, zodat het model niet grijpt naar syntax die je niet kunt uitvoeren. Zeg "alleen standaardbibliotheken" tenzij je echt third-party packages wilt. En vraag om een kort antwoord, omdat lange uitleg output-tokens kost en de code zelden verandert. Als het model blijft toevoegen na het blok, geef een stop-sequentie door, of verwijder alles buiten de code fence zoals de regex doet.
Workflow 2: het model zijn eigen code laten runnen en fixen
De grootste sprong in betrouwbaarheid komt meestal van tool calling. In plaats van om code te vragen en te hopen, geef je het model een functie die een script uitvoert en de uitvoer retourneert. Het schrijft code, voert deze uit, leest de traceback en corrigeert zichzelf. Tool-resultaten gaan terug als berichten met role: "tool", gekoppeld via 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"]),
})
Behandel de functie run_python met zorg. Deze voert code uit die het model heeft geschreven, op jouw machine, met jouw rechten. Voor alles wat verder gaat dan een wegwerexperiment, voer het uit in een container of een verwijderbare virtuele machine, zonder netwerk, met een tijdslimiet en geen toegang tot je inloggegevens. De time-out van tien seconden en de bijgesneden uitvoer in het voorbeeld zijn het minimum.
De lus is beperkt tot vijf rondes, zodat een verward model niet oneindig kan draaien. In de praktijk hebben de meeste eenvoudige functies één of twee runs nodig. Als je ziet dat het model dezelfde mislukte oproep herhaalt, voeg dan de traceback toe aan het volgende user-bericht in woorden, of verlaag de temperatuur. Houd er rekening mee dat een gestreamd tool-calling-verzoek zijn concurrency-slot vasthoudt tot de stream eindigt, en een volledige sleutel staat 8 gelijktijdige verzoeken toe, dus een team dat één sleutel deelt, moet agent-runs in de wachtrij plaatsen.
Workflow 3: gestructureerde codereview met JSON-modus
Reviews zijn nuttig wanneer een script ze kan lezen. JSON-modus forceert geldige JSON, en het systeembericht definieert de vorm. Met temperature 0 en een vaste seed levert hetzelfde bestand bij herhaalde runs dezelfde review op, wat diffs tussen runs betekenisvol maakt.
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"])
Gebruik dit vanuit een pre-commit hook of een CI-stap, en print het resultaat als annotaties. Verwacht false positives en false negatives. Een modelreviewer is een tweede paar ogen dat snel is en nooit moe, maar het vervangt geen tests, een type checker of een linter. Voer die eerst uit en gebruik het model voor wat zij niet kunnen zien, zoals onduidelijke namen, ontbrekende edge cases en error handling die exceptions opslokt.
Het contextvenster van 100.000 tokens staat hele bestanden en soms kleine packages toe in één verzoek. De body-limiet is 8 MB, wat je met broncode niet zult bereiken. Als een review wordt afgekapt, controleer dan of je max_tokens te laag hebt ingesteld; de parameter is optioneel en een completion kan wat over is van het contextvenster gebruiken.
Modellen testen op je eigen taken
Hier is een kleine harness die doet wat een ranglijst niet kan: het voert je taken uit tegen je tests. Elke taak heeft een prompt en een testsnippet. Het script vraagt het model meerdere keren om code, voegt de test toe aan de code, voert het resultaat uit en telt het aantal geslaagde tests. Wijzig de base URL en de modelnaam om een andere provider op dezelfde manier te vergelijken.
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")
Breid de takenlijst uit naar 30 of 50 items uit echt werk: een bug die je vorige maand oploste, een parser die je schreef, een functie met een lastige edge case. Neem ook taken op die andere tools weigerden of aarzelden. Voer elke taak drie tot vijf keer uit, omdat één sample weinig zegt. Noteer het slagingspercentage, de gemiddelde uitvoergrootte en de kosten per taak, en bewaar de resultaten in een bestand zodat je ze kunt herhalen na het wijzigen van prompts. Voer gegenereerde code uit in een sandbox, zoals hierboven opgemerkt.
Kijk naar de fouten, niet alleen naar het percentage. Als de meeste missers komen van één bibliotheek, voeg dan een hint toe aan het systeembericht. Als ze komen van het model dat functienamen verzint, geef dan de relevante handtekeningen in de prompt. Als ze komen van lange inputs, test dan een kortere prompt voordat je het model de schuld geeft.
Wat codewerk kost
Prijzen zijn $0,15 per 1M input-tokens en $0,50 per 1M output-tokens, en mislukte of geweigerde verzoeken worden niet in rekening gebracht. Drie voorbeelden met de wiskunde:
- Evaluatierun. 50 taken x 3 samples is 150 oproepen. Bij 400 input en 600 output tokens elk, is input 60.000 tokens ($0,009) en output 90.000 tokens ($0,045). Totaal: $0,054.
- Bestand controleren. Een bestand van ongeveer 600 regels is ongeveer 8.000 tokens, met een review van 1.200 tokens. Invoer kost $0,0012, uitvoer kost $0,0006, totaal $0,0018. Vijfhonderd reviews kosten $0,90.
- Agent-loop. Een fix met zes rondes die in totaal 18.000 invoertokens verstuurt en 1.500 uitvoertokens ontvangt, kost $0,0027 plus $0,00075, dus $0,00345.
Agent-loops domineren omdat elke ronde de groeiende conversatie opnieuw verzendt. Knip tool-output, zoals het voorbeeld doet, en je beheerst de meeste kosten. Opwaarderingen zijn elk geheel bedrag van $20 tot $500 met +5% vanaf $50, +10% vanaf $100 en +15% vanaf $200, betaald in USDT op TRC20 of USDC op Base, zonder verval van tegoed. Zie pricing. Nieuwe accounts kunnen ook $0,50 aan gratis proeftegoed claimen met één klik, wat een paar evaluatierondes financiert. Een trial key staat 2 gelijktijdige verzoeken en 60 per minuut toe.
Wanneer een andere keuze beter is
Wees eerlijk over de limieten van elk enkel endpoint. Als je een editor-plugin met inline-aanvullingen wilt, een door de leverancier gebouwde coding agent of strakke integratie met de tooling van één cloud, kan een daarvoor gebouwd product je beter dienen, en moet je hun huidige prijzen en voorwaarden controleren. Als je code nooit een afwijzing triggerd, geeft het afwijzingsgedrag van dit model je geen voordeel, en moeten je testresultaten beslissen. Als je embeddings of afbeeldingsinvoer nodig hebt, heb je een andere service nodig voor die onderdelen. Deze API is een goede match als je een plat OpenAI-compatible endpoint wilt dat je vanuit scripts en tools kunt aanroepen, met een groot venster, tool calling en een lage prijs. De API docs vermelden de volledige parameter set.
Meer handleidingen
Vragen en antwoorden
Is dit het juiste model voor Python-werk?
Geen enkel model is het beste voor elke taak. Deze API biedt één open-weight model met function calling, JSON-modus en een contextvenster van 100.000 tokens, en de bovenstaande harness stelt je in staat het te meten tegen je eigen tests.
Kan het model mijn Python-code uitvoeren?
Niet vanzelf. Je definieert een tool, zoals run_python, en jouw code voert deze uit en retourneert de output als een toolbericht. Voer het uit in een sandbox.
Hoe groot is een codebase die in één verzoek past?
Het venster is 100.000 tokens voor prompt plus antwoord. Dat dekt veel bestanden tegelijk, maar niet een hele grote repository.
Werkt het met het OpenAI Python-pakket?
Ja. Stel base_url in op de API-URL, geef je sleutel door en gebruik de model-ID uncensored.
Hoeveel kost een testrun?
Een reeks van 150 code-aanroepen met elk 400 invoer- en 600 uitvoertokens kost ongeveer $0,054.
Je sleutel is nog maar één formulier verwijderd
Maak een account aan, kopieer de sleutel, pas de base URL aan. Dat is de hele setup.
Basis-URLhttps://api.visionllmapi.com/v1