Fill-In-The-Middle (FIM)
På denna sida
Principen Fill-In-The-Middle
Fill-In-The-Middle, eller FIM, är Codestrals mest utmärkande förmåga. Vid vanlig generering utökar en modell text från en startpunkt utan något annat att ta hänsyn till. FIM ändrar spelreglerna: det låter dig fylla ett gap mitt i koden. Du anger början, kallad prompt, och slutet, kallat suffix, så genererar Codestral den mellanliggande koden som sammanfogar de två delarna på ett rent sätt.
Denna mekanik löser ett mycket konkret problem i IDE-autokomplettering. När du skriver mitt i en fil beror ett relevant förslag lika mycket på vad som följer efter markören som på vad som föregår den. En metod som infogas mellan två andra måste respektera deras stil, namngivningskonventioner och klassens implicita kontrakt. En modell som bara ser kontexten uppströms föreslår trolig kod som ofta är redundant i förhållande till vad som redan finns tio rader längre ner.
Operationen kokar ner till tre element. Prompten innehåller koden före infogningspunkten – med andra ord det du redan har skrivit före markören. Suffixet innehåller koden efter markören. Kompletteringen är fragmentet som genereras av Codestral, vilket placeras in mellan de två. Slutresultatet lyder alltid samma ekvation: prompt + completion + suffix = complete code.
Slutpunkten /v1/fim/completions
Mistral AI exponerar FIM via en dedikerad slutpunkt. Till skillnad från den vanliga chattslutpunkten accepterar denna parametrarna prompt och suffix istället för en meddelandearray.
Begärandestruktur
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)
Här får Codestral funktionssignaturen för fibonacci som prompt och anropskoden som suffix. Dess uppgift är att generera kroppen som gör denna signatur till en fungerande implementation, med vetskap om att funktionen anropas med ett heltal som matas in via tangentbordet och att dess returvärde skrivs ut direkt.
Viktiga parametrar
model— alltid"codestral-latest"för FIMprompt— koden före markören (krävs)suffix— koden efter markören (valfritt men rekommenderas)temperature—0för deterministiska resultat,0,2–0,7för variationmax_tokens— begränsar längden på den genererade kompletteringenstop— lista med stopptoken (t.ex.["\n\n"]för att stoppa efter ett block)
Konkret exempel: Komplettera en Python-klass
Låt oss titta på ett vanligt scenario: du skriver en tjänst och saknar en metod mitt i klassen.
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,
)
Suffixet gör hela grovjobbet när det gäller kontext. Genom att se delete_user lär sig Codestral tre saker: klassen frågar databasen via self.db.execute, den använder parametriserade frågor med ?, och den returnerar resultatet direkt utan ett mellanliggande lager. Den härleder att get_user måste följa exakt samma mönster och genererar:
return self.db.execute("SELECT * FROM users WHERE id = ?", (user_id,))
Prova övningen igen utan suffixet, så ser du skillnaden. Utan denna ankare kommer modellen ofta att hitta på ett ORM eller en cursor som inte finns någonstans i ditt projekt.
FIM kontra chatt: Välj rätt verktyg
| Situation | Slutpunkt | Varför |
|---|---|---|
| Autokomplettering i en IDE | FIM | Kontext före OCH efter markören är tillgänglig |
| Generera en hel funktion | Chatt | Inget suffix behövs |
| Komplettera en konfigurationsfil | FIM | Befintligt format och struktur styr kompletteringen |
| Förklara kod | Chatt | Uppgift i naturligt språk, inte komplettering |
| Skriva enhetstester | Chatt eller FIM | FIM om testfilen redan finns delvis |
Få ut mesta möjliga av FIM
Kvaliteten på kompletteringen beror först och främst på den kontext du tillhandahåller. Inkludera importsatser, föräldraklassen och närliggande funktioner i prompten. Dessa talar om för modellen vilka bibliotek som finns tillgängliga och vilken stil den ska anta. Suffixet förtjänar särskild uppmärksamhet, för utan det degraderas FIM till vanlig generering och förlorar sitt värde.
När det gäller inställningar fungerar IDE-autokomplettering bäst vid temperature=0 så att samma situation alltid ger samma förslag. En utvecklare som ser förslaget ändras vid varje tangenttryckning kommer så småningom att inaktivera funktionen. Håll max_tokens lågt, mellan 50 och 200, eftersom du kompletterar en rad eller ett block, inte en hel modul. Slutligen förhindrar stopptoken överflöd: stop=["\n\n"] klipper av genereringen vid slutet av det aktuella blocket istället för att låta modellen skriva om halva filen.
Viktiga punkter
- FIM kompletterar kod mellan en prompt (före) och ett suffix (efter)
- Den dedikerade slutpunkten är
/v1/fim/completions - Resultatet är: prompt + completion + suffix = complete code
- Suffixet är avgörande för högvärdiga kontextuella kompletteringar
- Använd
temperature=0och tokenbegränsningar för IDE-autokomplettering