Fill-In-The-Middle (FIM)

Le principe du Fill-In-The-Middle

Le Fill-In-The-Middle, ou FIM, est la capacité la plus distinctive de Codestral. Dans la génération classique, le modèle prolonge un texte à partir d’un point de départ et n’a rien d’autre à considérer. Le FIM change la donne : il permet de compléter un trou au milieu du code. Vous fournissez le début, appelé prompt, et la fin, appelée suffix, et Codestral produit le code intermédiaire qui relie proprement les deux.

Cette mécanique répond à un problème très concret de l’autocomplétion dans les IDE. Quand vous écrivez au milieu d’un fichier, la suggestion pertinente dépend autant de ce qui suit le curseur que de ce qui le précède : une méthode insérée entre deux autres doit respecter leur style, leur convention de nommage et le contrat implicite de la classe. Un modèle qui ne voit que l’amont propose du code plausible mais souvent redondant avec ce qui existe déjà dix lignes plus bas.

Le fonctionnement se résume à trois éléments. Le prompt contient le code qui précède le point d’insertion, autrement dit ce que vous avez déjà écrit avant le curseur. Le suffix contient le code qui le suit, c’est-à-dire ce qui existe après le curseur. La complétion est le fragment généré par Codestral, qui vient s’intercaler entre les deux. Le résultat final obéit donc toujours à la même équation : 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)

Codestral reçoit ici la signature de la fonction fibonacci comme prompt et le code d’appel comme suffix. Sa tâche est de générer le corps qui transforme cette signature en implémentation fonctionnelle, en sachant que la fonction sera appelée avec un entier saisi au clavier et que son retour sera affiché tel quel.

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

Prenons une situation courante : vous écrivez un service et il vous manque une méthode au milieu de la classe.

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

Le suffix fait tout le travail d’orientation. En voyant delete_user, Codestral apprend trois choses : la classe interroge la base par self.db.execute, elle utilise des requêtes paramétrées avec ?, et elle retourne directement le résultat sans couche intermédiaire. Il en déduit que get_user doit suivre exactement la même écriture et génère :

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

Reprenez l’exercice en supprimant le suffix, et vous verrez la différence : le modèle, privé de ce repère, inventera souvent un ORM ou un curseur qui n’existent nulle part dans votre projet.

FIM ou Chat : trancher selon la situation

Tirer le meilleur du FIM

La qualité d’une complétion dépend d’abord du contexte que vous transmettez. Incluez dans le prompt les imports, la classe parente et les fonctions voisines : ce sont eux qui indiquent au modèle quelles bibliothèques sont disponibles et quel style adopter. Le suffix mérite une attention particulière, car sans lui le FIM se dégrade en génération classique et perd tout son intérêt.

Côté réglages, l’autocomplétion IDE se pratique à temperature=0, pour que la même situation produise toujours la même suggestion — un développeur qui voit varier la proposition à chaque frappe finit par la désactiver. Gardez max_tokens bas, entre 50 et 200, puisqu’on complète une ligne ou un bloc, pas un module entier. Enfin, les tokens d’arrêt évitent les débordements : stop=["\n\n"] coupe la génération à la fin du bloc courant plutôt que de laisser le modèle réécrire la moitié du fichier.

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