Meilleur LLM local pour le code Python : API locale ou hébergée ?

Commencez par vos contraintes, pas par un nom de modèle

La question du meilleur LLM local pour le code Python n'a pas de réponse fixe : les modèles évoluent vite et votre machine est la vraie limite. Avant de comparer les noms, notez quatre éléments :

• Mémoire GPU. Elle détermine quelles tailles de modèles vous pouvez exécuter.
• Besoins en contexte. Modifier une fonction diffère de raisonner sur un package entier.
• Règles de confidentialité. Certains codes ne doivent pas quitter votre machine, justifiant un choix local.
• Tolérance aux refus. Les outils de sécurité, scrapers, ingénierie inverse et fuzzers peuvent déclencher des refus dans les modèles fortement filtrés.

Si l'opération hors ligne stricte est une exigence, vous devez exécuter vous-même un modèle. Sinon, une API hébergée supprime la question matérielle. Ce site est une API hébergée compatible OpenAI, pas un environnement local, et mérite d'être testé à côté de votre setup local.

Mémoire GPU nécessaire

Une règle approximative pour les poids : paramètres fois octets par paramètre. À une précision de 16 bits, cela représente 2 octets par paramètre ; à 8 bits, 1 octet ; à 4 bits, environ 0,5 octet.

Taille du modèle	16 bits	8 bits	4 bits
7B	14 Go	7 Go	3,5 Go
14B	28 Go	14 Go	7 Go
32B	64 Go	32 Go	16 Go

Ces chiffres concernent les poids seuls. Il faut aussi de la mémoire pour le cache de contexte (croît avec le prompt) et le runtime. Laissez une marge de quelques gigaoctets, plus si vous collez de gros fichiers. Une quantification plus lourde économise de la mémoire mais peut coûter en précision, ce qui compte pour le code où un seul caractère erroné casse le programme.

Comment comparer équitablement les modèles de programmation

Les classements publics mesurent les tâches d'autres. Une meilleure méthode prend une heure et utilise votre propre code.

1. Récoltez 15 à 20 tâches réelles : un bug avec un test en échec, une fonction à écrire à partir d’une docstring, une refactorisation, une requête pour ajouter des annotations de type.
2. Exécutez chaque modèle avec le même prompt, la même température (0,2 est un bon départ pour le code) et la même seed si pris en charge.
3. Évaluez en exécutant les tests, pas en lisant la réponse. Importe-t-il de vrais modules ? Le test passe-t-il ?
4. Notez les refus séparément. Un modèle 5 % meilleur sur le code mais refusant votre tâche de scanner de ports est pire pour vous.
5. Enregistrez le temps par tâche et, pour les modèles hébergés, le coût par tâche.

Gardez le harness dans un fichier pour le relancer quand un nouveau modèle apparaît. Cette réutilisation vaut plus que n'importe quel résultat unique.

Tester une option hébergée sur les mêmes tâches

L'API étant compatible OpenAI, votre harness nécessite juste une base URL différente. Ce script demande une fonction, extrait le premier bloc Python et l'exécute contre un test. L'ID de modèle est 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())

Exécutez la même liste de tâches contre votre modèle local et comparez les taux de réussite. Le code généré s’exécute, donc utilisez un répertoire jetable ou un conteneur pour tout ce qui dépasse les exemples simples.

Où un modèle hébergé aide un développeur Python

Un endpoint hébergé n’est pas toujours le meilleur choix, mais certaines tâches s’y prêtent bien :

• Grand contexte. La fenêtre est de 100 000 tokens, prompt plus complétion. Cela convient à un module de taille importante, ses tests et une trace d’erreur dans une seule requête.
• Appel de fonctions. Vous pouvez définir des outils comme run_tests ou read_file et laisser le modèle les appeler en boucle, les résultats étant renvoyés sous forme de messages role: "tool".
• Mode JSON. Avec response_format: {"type":"json_object"} vous pouvez obtenir une revue de code structurée, telle qu’une liste de problèmes avec des numéros de ligne.
• Moins de refus pour les tâches de sécurité. Le modèle est ajusté pour répondre sans refus de contenu pour un usage adulte licite, ce qui inclut les tests de sécurité de systèmes que vous possédez ou que vous êtes autorisé à tester.

Le compromis est clair : votre code quitte votre machine et vous avez besoin d’une connexion réseau. Les prompts ne sont pas utilisés pour l’entraînement, mais si votre politique interdit d’envoyer du code à un tiers, restez en local.

Laisser le modèle exécuter vos tests avec l’appel de fonctions

L’appel de fonctions transforme une réponse unique en boucle : le modèle demande d’exécuter les tests, observe l’échec et corrige le code. Définissez un seul outil et gérez l’appel vous-même.

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

La boucle est limitée à cinq tours pour qu’un modèle confus ne puisse pas tourner indéfiniment. Gardez la sortie des outils courte, car tout ce que vous retournez est facturé en entrée au tour suivant. La limiter aux 4 000 derniers caractères rend chaque tour peu coûteux.

Coût des tâches de codage

Les prompts de codage sont lourds en entrée : vous collez du code et obtenez une réponse plus courte. Prenons une demande de refactoring avec 6 000 tokens d’entrée et 1 500 tokens de sortie à $0,15 et $0,50 par 1 M :

• Entrée : 6 000 / 1 000 000 x $0,15 = $0,0009
• Sortie : 1 500 / 1 000 000 x $0,50 = $0,00075
• Total : $0,00165 par requête

Un millier de telles requêtes coûtent 1,65 $. Le crédit d’essai de 0,50 $ couvre environ 303 d’entre elles, suffisant pour exécuter un benchmark de 20 tâches plusieurs fois. Un GPU local peut être moins cher par requête à fort volume, mais il a un coût initial et ne diminue pas à zéro lorsque vous ne l’utilisez pas. La page de tarification contient le tableau complet.

Paramètres pratiques pour la génération de code

• Température de 0,1 à 0,3. Les valeurs plus faibles réduisent les API inventées et les changements de style aléatoires.
• Fixez une graine lorsque vous comparez des prompts, afin que les différences proviennent du prompt et non de l’échantillonnage.
• Indiquez la version Python et les bibliothèques dans le message système : « Python 3.11, bibliothèque standard uniquement » élimine une grande partie des suppositions.
• Demandez des tests avec le code. Un modèle qui écrit ses propres tests détecte souvent ses propres erreurs de décalage d’un cran lorsque vous les exécutez.
• Envoyez la traceback de l’échec, pas une description de celle-ci.

Pour l’essayer, activez l’essai sur la page de la clé API, puis suivez le guide de démarrage rapide. Pour une utilisation de type chat, consultez le guide de chat LLM sans censure. Le service est destiné à un usage adulte licite et ne génère pas de contenu sexuel impliquant des mineurs.

Écueils courants avec les modèles de codage

• Imports et noms de fonctions inventés. Exécutez le code. Un modèle peut décrire une méthode de bibliothèque qui n’existe pas, le test est donc le seul juge.
• Syntaxe obsolète. Si vous avez besoin de fonctionnalités modernes comme le filtrage par motifs structurel, indiquez la version Python dans le prompt.
• Trop de contexte. Une fenêtre plus grande ne signifie pas que vous devez tout coller. Envoyez les fichiers importants, ainsi que l’erreur.
• Faire confiance au code de sécurité généré. Examinez manuellement tout ce qui touche à l’authentification, à la crypto ou à l’analyse d’entrée.
• Exécuter la sortie aveuglément. Le code généré peut supprimer des fichiers ou effectuer des appels réseau. Utilisez un bac à sable.

Plus de guides

• Combien coûte un LLM ? Calculs et exemples par token
• Chat LLM sans censure : Guide d’intégration et cas d’usage