DE ▾
API-Schlüssel erhalten

Bestes LLM für Python-Programmierung: So wählst und testest du es

Es gibt kein einzelnes bestes LLM für Python, da die Antwort von deinen Aufgaben, der Kontextgröße und dem Preis pro Anfrage abhängt. Dieser Artikel liefert dir die Kriterien, funktionierenden Code für drei Programmier-Workflows und eine kleine Testumgebung, um Modelle an deiner eigenen Arbeit zu vergleichen.

Aktualisiert

Isometrische Datenströme, die durch ein Zahnrad fließen und als gestapelte Codeblöcke für die Python-Programmierung mit einer LLM-API austreten

Wichtige Punkte

  • Öffentliche Ranglisten sind ein Ausgangspunkt. Ein 50-Aufgaben-Test an deiner eigenen Codebasis sagt dir mehr.
  • Prüfe für API-Nutzung Kontextgröße, Function Calling, JSON-Modus, deterministische Einstellungen und Preis pro Anfrage.
  • Diese API bedient ein Open-Weight-Modell mit einem 100.000-Token-Fenster, Function Calling und JSON-Modus zu $0,15 und $0,50 pro 1 Mio. Token.
  • Eine Evaluierungsausführung mit 150 Aufrufen kostet etwa 5 Cent, also ist Messen günstiger als Raten.

Warum kein Modell für alle das Beste ist

Python-Programmierung umfasst sehr unterschiedliche Aufgaben. Das Schreiben eines zehn Zeilen langen Hilfsprogramms, das Refaktorisieren eines 2.000-Zeilen-Moduls, das Lesen einer Stack-Ablaufverfolgung, das Generieren von Tests, das Übersetzen eines Shell-Skripts in Python und das Erstellen eines Tools, das Dateien bearbeitet, sind alles Programmieraufgaben, und ein Modell kann in einem Bereich stark und in einem anderen mittelmäßig sein. Leaderboards mitteln über viele Aufgaben und viele Sprachen hinweg. Dein Repository, deine Stilregeln und deine Bibliotheken sind nur ein schmaler Ausschnitt davon.

Die praktische Antwort auf die Frage ist also ein Verfahren. Entscheide, was du brauchst, kürze die Auswahl auf zwei oder drei Modelle, die die technischen Anforderungen erfüllen, führe dieselben Aufgaben durch jedes hindurch und zähle, wie viele deine eigenen Tests bestehen. Der Rest dieses Artikels behandelt die Anforderungen und zeigt dann, wie du die Tests gegen diese API durchführst.

Ein weiterer Punkt vor den Details. Der Dienst hinter dieser Website betreibt ein Open-Weight-Modell, das von einem unabhängigen Anbieter betrieben wird und darauf abgestimmt ist, ohne Inhaltsablehnungen für die rechtmäßige Nutzung durch Erwachsene zu antworten. Es ist nicht die offizielle API eines Modellherstellers, und es gibt hier keine Benchmark-Ansprüche. Betrachte es als einen Kandidaten für deine Shortlist und bewerte es wie jedes andere.

Die Kriterien, die für eine API wichtig sind

Wenn du ein Modell aus Code aufrufst, anstatt damit in einem Editor zu chatten, entscheiden einige technische Eigenschaften darüber, ob es passt.

KriteriumWarum es für Python-Aufgaben wichtig istDiese API
KontextfensterGanze Module, lange Tracebacks und Testausgaben müssen mit Platz für die Antwort passen100.000 Token, Prompt plus Vervollständigung
Function CallingErmöglicht dem Modell, Code, Tests und Linter auszuführen und dann auf die Ausgabe zu reagierenJa: Tools, tool_choice, gestreamte tool_calls
JSON-ModusMaschinenlesbare Überprüfungen, Linter-Berichte und RefaktorierungspläneJa: response_format json_object
ReproduzierbarkeitNiedrigere Temperatur und ein fester Seed machen Testausführungen vergleichbarTemperatur, top_p, Stop, Seed und Strafen werden durchgereicht
StreamingResponsive Tools und lange GenerierungenSSE mit Nutzungsinformationen am Ende
PreisAgent-Schleifen senden Kontext viele Male erneut$0,15 Input und $0,50 Output pro 1 Mio. Token
AblehnungenSecurity-Tooling, Scraper und Red-Team-Skripte für Systeme, die du besitzt, sind rechtmäßig, werden aber oft abgelehntAbgestimmt darauf, ohne Inhaltsablehnungen für legale Erwachsenennutzung zu antworten

Die Tabelle sagt nichts über die Codequalität aus, da die oben genannten Eigenschaften Fakten sind und Qualität etwas, das du testest. Qualität ändert sich auch mit dem Prompt. Eine Systemnachricht, die die Python-Version, die erlaubten Bibliotheken und das Antwortformat fixiert, ist oft genauso wichtig wie das Modell.

Diese API ist nur Text. Du sendest Code als Text im Prompt und erhältst Text zurück. Es gibt keine Bild-, Audio- oder Videogenerierung, keine Embeddings und kein Fine-Tuning, also muss ein Codesuchsystem, das Embeddings benötigt, diese woanders beziehen.

Workflow 1: Funktion mit einem strikten Prompt generieren

Beginne mit dem einfachsten Fall: Bitte um eine Funktion und extrahiere den Codeblock. Niedrige Temperatur liefert stabile Ausgaben. Die Systemnachricht fixiert die Sprachversion und das Antwortformat, was die Extraktion zu einer einzeiligen Regex macht. Hol dir einen Schlüssel von der Schlüsselseite und exportiere ihn 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."))

Drei Prompt-Gewohnheiten helfen hier. Nenne die Python-Version, damit das Modell nicht auf Syntax zurückgreift, die du nicht ausführen kannst. Sage „nur Standardbibliothek“, es sei denn, du willst wirklich Pakete von Drittanbietern. Und bitte um eine kurze Antwort, da lange Erklärungen Output-Token kosten und den Code selten verändern. Wenn das Modell nach dem Block weiterhin Text hinzufügt, übergebe eine stop-Sequenz oder entferne alles außerhalb des Blocks, wie es die Regex tut.

Workflow 2: Das Modell ausführen und seinen eigenen Code korrigieren lassen

Der größte Sprung in der Zuverlässigkeit kommt normalerweise vom Tool Calling. Statt nach Code zu fragen und zu hoffen, gibst du dem Modell eine Funktion, die ein Skript ausführt und die Ausgabe zurückgibt. Es schreibt Code, führt ihn aus, liest den Traceback und korrigiert sich selbst. Tool-Ergebnisse gehen als Nachrichten mit role: "tool" zurück, abgeglichen über 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"]),
        })

Behandle die run_python-Funktion mit Sorgfalt. Sie führt Code aus, den das Modell geschrieben hat, auf deinem Rechner, mit deinen Berechtigungen. Für alles, was über ein Wegwerfexperiment hinausgeht, führe es in einem Container oder einer Disposable VM aus, ohne Netzwerk, mit einer Zeitbegrenzung und ohne Zugriff auf deine Anmeldeinformationen. Die zehn Sekunden Timeout und die beschnittene Ausgabe im Beispiel sind das Minimum.

Die Schleife ist auf fünf Runden begrenzt, damit ein verwirrtes Modell nicht endlos dreht. In der Praxis benötigen die meisten einfachen Funktionen ein oder zwei Durchläufe. Wenn du siehst, dass das Modell denselben fehlgeschlagenen Aufruf wiederholt, füge den Traceback in Worten zur nächsten Benutzernachricht hinzu oder senke die Temperatur. Beachte, dass eine gestreamte Function-Calling-Anfrage ihren Concurrency-Slot hält, bis der Stream endet, und ein vollständiger Schlüssel 8 gleichzeitige Anfragen erlaubt, also sollte ein Team, das einen Schlüssel teilt, Agent-Ausführungen in eine Warteschlange stellen.

Workflow 3: Strukturierte Code-Überprüfung mit JSON-Modus

Überprüfungen sind nützlich, wenn ein Skript sie lesen kann. JSON-Modus erzwingt gültiges JSON, und die Systemnachricht definiert die Form. Mit temperature 0 und einem festen seed erzeugt dieselbe Datei bei wiederholten Durchläufen dieselbe Überprüfung, was Diffs zwischen Durchläufen sinnvoll macht.

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

Verwende dies aus einem Pre-Commit-Hook oder einem CI-Schritt und gib das Ergebnis als Annotationen aus. Erwarte falsch positive und falsch negative Ergebnisse. Ein Modellprüfer ist ein zweites Paar Augen, das schnell und nie müde ist, aber es ersetzt keine Tests, einen Typenprüfer oder einen Linter. Führe diese zuerst aus und nutze das Modell für das, was sie nicht sehen können, wie unklare Benennungen, fehlende Randfälle und Fehlerbehandlung, die Ausnahmen verschluckt.

Das Fenster von 100.000 Token ermöglicht ganze Dateien und manchmal kleine Pakete in einer einzigen Anfrage. Die Körpergrenze beträgt 8 MB, was du mit Quellcode nicht erreichen wirst. Wenn eine Überprüfung abgeschnitten wird, prüfe, ob du max_tokens zu niedrig gesetzt hast; der Parameter ist optional und eine Vervollständigung kann den Rest des Fensters nutzen.

Modelle an deinen eigenen Aufgaben testen

Hier ist ein kleines Test-Setup, das das macht, was ein Leaderboard nicht kann: Es führt deine Aufgaben gegen deine Tests aus. Jede Aufgabe enthält einen Prompt und einen Test-Snippet. Das Skript fragt das Modell mehrmals nach Code, hängt den Test an den Code an, führt das Ergebnis aus und zählt die Erfolge. Ändere die Base URL und den Modellnamen, um einen anderen Anbieter auf die gleiche Weise zu vergleichen.

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

Erweitere die Aufgabenliste auf 30 oder 50 Einträge aus der echten Arbeit: einen Bug, den du letzten Monat behoben hast, einen Parser, den du geschrieben hast, eine Funktion mit einem sperrigen Sonderfall. Füge Aufgaben hinzu, bei denen andere Tools abgelehnt oder gezögert haben. Führe jede Aufgabe drei bis fünf Mal aus, denn eine einzelne Probe sagt wenig aus. Notiere die Erfolgsquote, die durchschnittliche Ausgabelänge und die Kosten pro Aufgabe, und bewahre die Ergebnisse in einer Datei auf, damit du sie nach Änderungen an den Prompts erneut ausführen kannst. Führe generierten Code in einer Sandbox aus, wie oben erwähnt.

Schau dir die Fehler an, nicht nur den Prozentsatz. Wenn die meisten Fehler von einer Bibliothek stammen, füge einen Hinweis in die Systemnachricht ein. Wenn sie vom Modell erdachte Funktionsnamen stammen, gib ihm die relevanten Signaturen im Prompt. Wenn sie von langen Eingaben stammen, teste einen kürzeren Prompt, bevor du das Modell beschuldigst.

Was Coding-Arbeit kostet

Die Preise betragen $0,15 pro 1 Mio. Input-Token und $0,50 pro 1 Mio. Output-Token, und fehlgeschlagene oder abgelehnte Anfragen werden nicht berechnet. Drei Beispiele mit der Mathematik:

  • Evaluierungsausführung. 50 Aufgaben x 3 Stichproben sind 150 Aufrufe. Bei 400 Input und 600 Output Token pro Aufruf sind Input 60.000 Token ($0,009) und Output 90.000 Token ($0,045). Gesamt: $0,054.
  • Dateiüberprüfung. Eine Datei mit etwa 600 Zeilen ist ungefähr 8.000 Token, mit einer 1.200-Token-Überprüfung. Input kostet $0,0012, Output kostet $0,0006, insgesamt $0,0018. Fünfhundert Überprüfungen kosten $0,90.
  • Agent-Schleife. Eine Fixierung mit sechs Runden, die insgesamt 18.000 Input-Token sendet und 1.500 Output-Token empfängt, kostet $0,0027 plus $0,00075, also $0,00345.

Agent-Schleifen dominieren, weil jede Runde die wachsende Konversation erneut sendet. Schneide Tool-Ausgaben zurück, wie das Beispiel zeigt, und du kontrollierst den Großteil der Rechnung. Aufladungen sind in jedem ganzen Betrag von $20 bis $500 möglich, mit +5% ab $50, +10% ab $100 und +15% ab $200, bezahlt in USDT auf TRC20 oder USDC auf Base, wobei das Guthaben nie verfällt. Siehe Preise. Neue Konten können auch $0,50 an kostenlosem Testguthaben mit einem Klick beanspruchen, das ein paar Evaluierungsläufe finanziert. Ein Test-Schlüssel erlaubt 2 parallele Anfragen und 60 pro Minute.

Wenn eine andere Wahl besser ist

Sei ehrlich bezüglich der Grenzen eines einzelnen Endpunkts. Wenn du ein Editor-Plugin mit Inline-Vervollständigung, einen von einem Anbieter entwickelten Coding-Agenten oder eine enge Integration mit den Tools einer bestimmten Cloud möchtest, könnte ein dafür entwickeltes Produkt besser zu dir passen, und du solltest deren aktuelle Preise und Nutzungsbedingungen prüfen. Wenn dein Code niemals eine Ablehnung auslöst, bietet dir das Ablehnungsverhalten dieses Modells keinen Vorteil, und deine Testergebnisse sollten entscheiden. Wenn du Embeddings oder Bild-Eingaben benötigst, brauchst du für diese Teile einen anderen Dienst. Diese API ist eine gute Wahl, wenn du einen einfachen OpenAI-kompatiblen Endpunkt möchtest, den du aus Skripten und Tools heraus aufrufen kannst, mit einem großen Kontextfenster, Function Calling und einem niedrigen Preis. Die API-Dokumentation listet den vollständigen Parametersatz auf.

02

Fragen und Antworten

Ist dies das richtige Modell für Python-Entwicklung?

Kein einzelnes Modell ist für jede Aufgabe am besten. Diese API bietet ein Open-Weight-Modell mit Function Calling, JSON-Modus und einem 100.000-Token-Kontextfenster, und das obige Framework ermöglicht es dir, es gegen deine eigenen Tests zu messen.

Kann das Modell meinen Python-Code ausführen?

Nicht von selbst. Du definierst ein Tool, z. B. run_python, und dein Code führt es aus und gibt die Ausgabe als Tool-Nachricht zurück. Führe es in einer Sandbox aus.

Wie groß ist ein Codebase, das in eine Anfrage passt?

Das Kontextfenster umfasst 100.000 Token für Prompt plus Antwort. Das deckt viele Dateien gleichzeitig ab, aber nicht ein gesamtes großes Repository.

Funktioniert es mit dem OpenAI Python-Paket?

Ja. Setze base_url auf die API-URL, übergebe deinen Schlüssel und verwende die Modell-ID uncensored.

Wie viel kostet ein Testlauf?

Ein Lauf mit 150 Coding-Aufrufen zu je 400 Input- und 600 Output-Token kostet etwa $0,054.

Dein Schlüssel ist nur ein Formular entfernt

Erstelle ein Konto, kopiere den Schlüssel, ändere die Basis-URL. Das ist die gesamte Einrichtung.

Basis-URLhttps://api.visionllmapi.com/v1

API-Schlüssel erhalten