Fill-In-The-Middle (FIM)

Le principe du Fill-In-The-Middle

Le Fill-In-The-Middle (FIM) est la capacité la plus distinctive de Codestral. Contrairement à la génération classique où le modèle continue du texte à partir d’un point de départ, le FIM permet au modèle de compléter un trou au milieu du code. Vous fournissez le début (le prompt) et la fin (le suffix), et Codestral génère le code intermédiaire qui relie les deux.

Cette approche résout un problème fondamental de l’autocomplétion dans les IDE : quand vous tapez du code au milieu d’un fichier, le modèle doit comprendre à la fois ce qui précède et ce qui suit le curseur pour proposer une complétion pertinente.

Comment fonctionne le FIM ?

Le mécanisme est simple mais puissant :

1. Prompt — le code qui précède le point d’insertion (ce que vous avez déjà écrit avant le curseur)
2. Suffix — le code qui suit le point d’insertion (ce qui existe après le curseur)
3. Complétion — le code généré par Codestral qui s’insère entre les deux

Le résultat final est : prompt + complétion + suffix = code complet

L’endpoint /v1/fim/completions

Mistral AI expose le FIM via un endpoint dédié. Contrairement à l’endpoint chat classique, celui-ci accepte les paramètres prompt et suffix au lieu d’un tableau de messages.

Structure de la requête

from mistralai import Mistral

client = Mistral(api_key="votre_clé_api")

response = client.fim.complete(
    model="codestral-latest",
    prompt="def fibonacci(n: int):",
    suffix="n = int(input('Entrez un nombre: '))\nprint(fibonacci(n))",
    temperature=0,
)

print(response.choices[0].message.content)

Dans cet exemple, Codestral reçoit la signature de la fonction fibonacci comme prompt et le code d’appel comme suffix. Il doit générer le corps de la fonction qui transforme la signature en une implémentation fonctionnelle.

Paramètres importants

• model — toujours "codestral-latest" pour le FIM
• prompt — le code avant le curseur (obligatoire)
• suffix — le code après le curseur (optionnel mais recommandé)
• temperature — 0 pour des résultats déterministes, 0.2-0.7 pour de la variété
• max_tokens — limite la longueur de la complétion générée
• stop — liste de tokens d’arrêt (ex: ["\n\n"] pour stopper après un bloc)

Exemple concret : compléter une classe Python

Imaginons que vous écrivez une classe et que vous avez besoin de compléter une méthode au milieu :

prompt = """class UserService:
    def __init__(self, db):
        self.db = db

    def get_user(self, user_id: int):
"""

suffix = """
    def delete_user(self, user_id: int):
        return self.db.execute("DELETE FROM users WHERE id = ?", (user_id,))
"""

response = client.fim.complete(
    model="codestral-latest",
    prompt=prompt,
    suffix=suffix,
    temperature=0,
    max_tokens=200,
)

Codestral comprend que get_user doit retourner un utilisateur depuis la base de données, en cohérence avec le style de delete_user qui suit. Il va générer quelque chose comme :

        return self.db.execute("SELECT * FROM users WHERE id = ?", (user_id,))

FIM vs Chat : quand utiliser quoi ?

Bonnes pratiques pour le FIM

• Incluez suffisamment de contexte dans le prompt — les imports, les classes parentes, les fonctions voisines aident le modèle
• Le suffix est crucial — sans lui, le FIM se comporte comme une génération classique
• Utilisez temperature=0 pour l’autocomplétion IDE (résultats prévisibles)
• Limitez max_tokens — pour l’autocomplétion, 50-200 tokens suffisent généralement
• Utilisez des tokens d’arrêt — stop=["\n\n"] empêche le modèle de générer trop de code

Points clés à retenir

• Le FIM complète du code entre un prompt (avant) et un suffix (après)
• L’endpoint dédié est /v1/fim/completions
• Le résultat est : prompt + complétion + suffix = code complet
• Le suffix est essentiel pour des complétions contextuelles de qualité
• Utilisez temperature=0 et des limites de tokens pour l’autocomplétion IDE