Vai al contenuto principale
Italiano— Scegli una lingua
Menu

Fill-In-The-Middle (FIM)

Lezione 2 di 14 Aggiornata il 2 novembre 2026 Sviluppatore
In questa pagina
  1. Il principio Fill-In-The-Middle
  2. L’endpoint /v1/fim/completions
  3. Esempio concreto: completamento di una classe Python
  4. FIM vs Chat: scegliere lo strumento giusto
  5. Sfruttare al meglio FIM
  6. Punti chiave

Il principio Fill-In-The-Middle

Fill-In-The-Middle, o FIM, è la capacità più distintiva di Codestral. Nella generazione standard, un modello estende il testo a partire da un punto iniziale senza nient’altro da considerare. FIM cambia le regole del gioco: ti permette di riempire uno spazio vuoto nel mezzo del codice. Fornisci l’inizio, chiamato prompt, e la fine, chiamata suffix, e Codestral genera il codice intermedio che collega perfettamente i due elementi.

Questo meccanismo risolve un problema molto concreto nell’autocompletamento degli IDE. Quando digiti nel mezzo di un file, un suggerimento pertinente dipende tanto da ciò che segue il cursore quanto da ciò che lo precede. Un metodo inserito tra altri due deve rispettarne lo stile, le convenzioni di denominazione e il contratto implicito della classe. Un modello che vede solo il contesto a monte propone codice plausibile, ma spesso ridondante rispetto a quanto già esistente dieci righe più in basso.

L’operazione si riduce a tre elementi. Il prompt contiene il codice prima del punto di inserimento, ovvero ciò che hai già scritto prima del cursore. Il suffix contiene il codice dopo il cursore. Il completion è il frammento generato da Codestral, che si inserisce tra i due. Il risultato finale obbedisce sempre alla stessa equazione: prompt + completion + suffix = complete code.

L’endpoint /v1/fim/completions

Mistral AI espone FIM tramite un endpoint dedicato. A differenza dell’endpoint chat standard, questo accetta i parametri prompt e suffix invece di un array di messaggi.

Struttura della richiesta

from mistralai.client import Mistral

client = Mistral(api_key="your_api_key")

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

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

Qui, Codestral riceve la firma della funzione fibonacci come prompt e il codice di chiamata come suffix. Il suo compito è generare il corpo che trasforma questa firma in un’implementazione funzionante, sapendo che la funzione verrà chiamata con un intero inserito tramite tastiera e che il suo valore di ritorno verrà stampato così com’è.

Parametri chiave

  • model — sempre "codestral-latest" per FIM
  • prompt — il codice prima del cursore (obbligatorio)
  • suffix — il codice dopo il cursore (opzionale ma raccomandato)
  • temperature — 0 per risultati deterministici, 0.2-0.7 per varietà
  • max_tokens — limita la lunghezza del completion generato
  • stop — lista di token di arresto (es. ["\n\n"] per fermarsi dopo un blocco)

Esempio concreto: completamento di una classe Python

Esaminiamo uno scenario comune: stai scrivendo un servizio e manca un metodo nel mezzo della 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,
)

Il suffix fa tutto il lavoro pesante riguardo al contesto. Vedendo delete_user, Codestral apprende tre cose: la classe interroga il database tramite self.db.execute, utilizza query parametrizzate con ? e restituisce il risultato direttamente senza un livello intermedio. Deduce che get_user deve seguire esattamente lo stesso schema e genera:

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

Riprova l’esercizio senza il suffix e vedrai la differenza. Privato di questo ancoraggio, il modello inventerà spesso un ORM o un cursore che non esistono da nessuna parte nel tuo progetto.

FIM vs Chat: scegliere lo strumento giusto

SituazioneEndpointPerché
Autocompletamento in un IDEFIMÈ disponibile il contesto prima E dopo il cursore
Generazione di una funzione completaChatNessun suffix necessario
Completamento di un file di configurazioneFIMFormato e struttura esistenti guidano il completion
Spiegazione del codiceChatCompito in linguaggio naturale, non completamento
Scrittura di test unitariChat o FIMFIM se il file di test esiste già parzialmente

Sfruttare al meglio FIM

La qualità del completion dipende innanzitutto dal contesto che fornisci. Includi nel prompt gli import, la classe genitore e le funzioni vicine. Questi indicano al modello quali librerie sono disponibili e quale stile adottare. Il suffix merita un’attenzione speciale perché, senza di esso, FIM degrada in una generazione standard perdendo il suo valore.

Per quanto riguarda le impostazioni, l’autocompletamento dell’IDE funziona meglio con temperature=0, così la stessa situazione produce sempre lo stesso suggerimento. Uno sviluppatore che vede la proposta cambiare a ogni tasto premuto alla fine lo disattiverà. Mantieni max_tokens basso, tra 50 e 200, dato che stai completando una riga o un blocco, non un intero modulo. Infine, i token di arresto prevengono lo sconfinamento: stop=["\n\n"] interrompe la generazione alla fine del blocco corrente invece di lasciare che il modello riscriva metà file.

Punti chiave

  • FIM completa il codice tra un prompt (prima) e un suffix (dopo)
  • L’endpoint dedicato è /v1/fim/completions
  • Il risultato è: prompt + completion + suffix = codice completo
  • Il suffix è essenziale per completion contestuali di alta qualità
  • Usa temperature=0 e limiti di token per l’autocompletamento negli IDE