Bestes lokales LLM für Python-Coding: Lokal oder gehostet per API?

Starte mit deinen Einschränkungen, nicht mit einem Modellnamen

Die Frage best local llm for python coding hat keine feste Antwort, weil sich Modelle schnell ändern und deine Maschine das eigentliche Limit ist. Bevor du Namen vergleichst, schreibe vier Dinge auf:

• GPU-Speicher. Dies entscheidet, welche Modellgrößen du überhaupt ausführen kannst.
• Kontextbedarf. Eine Funktion zu bearbeiten ist etwas anderes, als über ein ganzes Paket zu schlussfolgern.
• Datenschutzrichtlinien. Manche Codebasen dürfen deine Maschine nicht verlassen, was ein legitimer Grund ist, lokal zu bleiben.
• Ablehnungstoleranz. Security-Tooling, Scraper, Reverse Engineering und Fuzzer können Ablehnungen in stark gefilterten Modellen auslösen.

Wenn ein strikter Offline-Betrieb eine harte Anforderung ist, brauchst du ein Modell, das du selbst ausführst. Wenn nicht, entfernt eine gehostete API die Hardware-Frage. Diese Seite gehört zur zweiten Gruppe: Es ist eine gehostete, OpenAI-kompatible API, keine lokale Laufzeitumgebung, und es lohnt sich, sie neben deiner lokalen Einrichtung zu testen.

Wie viel GPU-Speicher du brauchst

Eine grobe Regel für Gewichte: Parameter mal Bytes pro Parameter. Bei 16-Bit-Präzision sind das 2 Bytes pro Parameter; bei 8-Bit, 1 Byte; bei 4-Bit, ca. 0,5 Bytes.

Modellgröße	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

Diese Werte gelten nur für die Gewichte. Du brauchst auch Speicher für den Kontext-Cache, der mit dem Prompt wächst, und für die Runtime selbst. Lasse ein paar Gigabyte Puffer und mehr, wenn du große Dateien einfügen willst. Schwerere Quantisierung spart Speicher, kann aber etwas Genauigkeit kosten, was bei Code wichtig ist, wo ein falsches Zeichen das Programm kaputt macht.

Wie man Coding-Modelle fair vergleicht

Öffentliche Leaderboards messen fremde Aufgaben. Eine bessere Methode dauert eine Stunde und nutzt deinen eigenen Code.

1. Sammle 15 bis 20 echte Aufgaben: Einen Bug mit einem fehlschlagenden Test, eine Funktion, die aus einem Docstring geschrieben werden soll, ein Refactoring, eine Anfrage, Type Hints hinzuzufügen.
2. Führe jedes Modell mit demselben Prompt, derselben Temperatur (0,2 ist ein sinnvoller Start für Code) und demselben Seed aus, wo unterstützt.
3. Bewerte durch Ausführen der Tests, nicht durch Lesen der Antwort. Importiert es echte Module? Besteht es?
4. Notiere Ablehnungen separat. Ein Modell, das 5 % besser im Code ist, aber deine Port-Scanner-Aufgabe ablehnt, ist für dich schlechter.
5. Notiere Zeit pro Aufgabe und, für gehostete Modelle, Kosten pro Aufgabe.

Halte das Test-Harness in einer Datei, damit du es neu ausführen kannst, wenn ein neues Modell erscheint. Diese Wiederverwendung ist mehr wert als jedes einzelne Ergebnis.

Testen einer gehosteten Option bei denselben Aufgaben

Da die API OpenAI-kompatibel ist, benötigt dein Test-Harness nur eine andere Base URL. Dieses Skript fragt eine Funktion ab, extrahiert den ersten Python-Block und führt ihn gegen einen Test aus. Die Modell-ID ist 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())

Führe dieselbe Aufgabenliste gegen dein lokales Modell aus und vergleiche die Bestehensquoten. Der Code führt generierte Ausgabe aus, also verwende ein Wegwerf-Verzeichnis oder einen Container für alles über einfache Beispiele hinaus.

Wo ein gehostetes Modell einem Python-Entwickler hilft

Ein gehosteter Endpunkt ist nicht in jedem Fall besser, aber einige Aufgaben eignen sich gut dafür:

• Großer Kontext. Das Kontextfenster umfasst 100.000 Token, sowohl Prompt als auch Completion. Darin haben ein größeres Modul, seine Tests und ein Stack Trace in einer einzigen Anfrage Platz.
• Function Calling. Du kannst Tools wie run_tests oder read_file definieren und das Modell sie in einer Schleife ausführen lassen, wobei die Ergebnisse als role: "tool"-Nachrichten zurückgesendet werden.
• JSON-Modus. Mit response_format: {"type":"json_object"} kannst du eine strukturierte Code-Überprüfung erhalten, etwa eine Liste von Problemen mit Zeilennummern.
• Weniger Ablehnungen bei Sicherheitsaufgaben. Das Modell ist darauf abgestimmt, ohne Inhaltsfilter bei rechtmäßiger Erwachsenennutzung zu antworten, was auch das Testen von Systemen umfasst, die dir gehören oder die du testen darfst.

Der Nachteil ist klar: Dein Code verlässt deinen Rechner und du benötigst eine Netzwerkverbindung. Prompts werden nicht zum Training verwendet, aber wenn deine Richtlinie das Senden von Code an Dritte verbietet, bleibe lokal.

Das Modell deine Tests mit Function Calling ausführen lassen

Function Calling verwandelt eine One-Shot-Antwort in eine Schleife: Das Modell fordert an, dass die Tests ausgeführt werden, sieht den Fehler und korrigiert den Code. Definiere ein Tool und handle den Aufruf selbst.

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

Die Schleife ist auf fünf Runden begrenzt, damit ein verwirrtes Modell nicht endlos läuft. Halte die Tool-Ausgabe kurz, denn alles, was du zurückgibst, wird im nächsten Durchlauf als Input abgerechnet. Begrenze sie auf die letzten 4.000 Zeichen, um jeden Durchlauf günstig zu halten.

Was Coding-Aufgaben kosten

Code-Prompts sind input-lastig: Du fügst Code ein und erhältst eine kürzere Antwort. Nimm eine Refactoring-Anfrage mit 6.000 Input-Token und 1.500 Output-Token zu $0,15 bzw. $0,50 pro 1 Mio.:

• Input: 6.000 / 1.000.000 x $0,15 = $0,0009
• Output: 1.500 / 1.000.000 x $0,50 = $0,00075
• Gesamt: $0,00165 pro Anfrage

Tausend solcher Anfragen kosten $1,65. Das Testguthaben von $0,50 reicht für etwa 303 Anfragen, genug, um einen Benchmark mit 20 Aufgaben mehrmals durchzuführen. Eine lokale GPU kann bei hohem Volumen pro Anfrage günstiger sein, hat aber Anschaffungskosten und sinkt nicht auf null, wenn du sie nicht nutzt. Die Preisseite enthält die vollständige Tabelle.

Praktische Einstellungen für die Codegenerierung

• Temperatur 0,1 bis 0,3. Niedrigere Werte reduzieren erfundene APIs und zufällige Stilwechsel.
• Fixiere einen Seed, wenn du Prompts vergleichst, damit Unterschiede vom Prompt und nicht vom Sampling stammen.
• Gib die Python-Version und die Bibliotheken in der Systemnachricht an: "Python 3.11, nur Standardbibliothek" entfernt viel Vermuten.
• Fordere Tests zum Code an. Ein Modell, das eigene Tests schreibt, fängt oft eigene Off-by-One-Fehler ab, wenn du sie ausführst.
• Sende den fehlgeschlagenen Traceback, nicht eine Beschreibung davon.

Um es auszuprobieren, aktiviere das Testguthaben auf der API-Schlüssel-Seite und folge dann der Schnellstart-Anleitung. Für Chat-ähnliche Nutzung sieh dir den uncensored LLM Chat-Leitfaden an. Der Dienst ist für die rechtmäßige Nutzung durch Erwachsene gedacht und erzeugt keine sexuellen Inhalte mit Minderjährigen.

Häufige Fallstricke bei Code-Modellen

• Erfundene Imports und Funktionsnamen. Führe den Code aus. Ein Modell kann eine Bibliotheksmethode beschreiben, die nicht existiert, daher ist der Test der einzige Richter.
• Veraltete Syntax. Wenn du moderne Funktionen wie strukturelle Mustererkennung benötigst, gib die Python-Version im Prompt an.
• Zu viel Kontext. Ein größeres Kontextfenster bedeutet nicht, dass du alles einfügen solltest. Sende die relevanten Dateien sowie den Fehler.
• Generiertem Sicherheitscode vertrauen. Überprüfe manuell alles, was mit Authentifizierung, Krypto oder Eingabeparsing zu tun hat.
• Generierte Ausgabe blind ausführen. Generierter Code kann Dateien löschen oder Netzwerkaufrufe tätigen. Verwende eine Sandbox.

Weitere Anleitungen

• Wie viel kostet ein LLM? Token-basierte Berechnung und Beispiele
• Unzensierter LLM-Chat: Integrationsleitfaden & Anwendungsfälle