Fill-In-The-Middle (FIM)
Op deze pagina
Het Fill-In-The-Middle-principe
Fill-In-The-Middle, of FIM, is de meest onderscheidende mogelijkheid van Codestral. Bij standaardgeneratie breidt een model tekst uit vanaf een startpunt zonder andere context. FIM verandert het spel: het stelt u in staat een gat in het midden van code op te vullen. U levert het begin, de prompt, en het einde, de suffix, en Codestral genereert de tussenliggende code die beide delen naadloos met elkaar verbindt.
Dit mechanisme lost een zeer concreet probleem op bij automatisch aanvullen in IDE’s. Wanneer u ergens in het midden van een bestand typt, hangt een relevant voorstel evenzeer af van wat er na de cursor staat als van wat er aan voorafgaat. Een methode die tussen twee andere methoden wordt ingevoegd, moet hun stijl, naamgevingsconventies en het impliciete contract van de klasse respecteren. Een model dat alleen de voorgaande context ziet, stelt plausibele code voor die vaak overbodig is met wat er tien regels verderop al staat.
De operatie komt neer op drie elementen. De prompt bevat de code vóór het invoegpunt – met andere woorden, wat u al hebt geschreven vóór de cursor. De suffix bevat de code na de cursor. De completion is het fragment dat door Codestral wordt gegenereerd en dat tussen beide delen past. Het eindresultaat volgt altijd dezelfde vergelijking: prompt + completion + suffix = complete code.
Het /v1/fim/completions-endpoint
Mistral AI stelt FIM beschikbaar via een specifiek endpoint. In tegenstelling tot het standaard chat-endpoint, accepteert dit endpoint de parameters prompt en suffix in plaats van een array met berichten.
Opbouw van het verzoek
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)
Hier ontvangt Codestral de functiesignatuur van fibonacci als prompt en de aanroepcode als suffix. De taak is om de body te genereren die van deze signatuur een werkende implementatie maakt, wetende dat de functie wordt aangeroepen met een via het toetsenbord ingevoerd geheel getal en dat de retourwaarde direct wordt afgedrukt.
Belangrijkste parameters
model— altijd"codestral-latest"voor FIMprompt— de code vóór de cursor (verplicht)suffix— de code na de cursor (optioneel, maar aanbevolen)temperature—0voor deterministische resultaten,0.2-0.7voor variatiemax_tokens— beperkt de lengte van de gegenereerde completionstop— lijst met stop-tokens (bijv.["\n\n"]om na een blok te stoppen)
Concreet voorbeeld: een Python-klasse aanvullen
Laten we een veelvoorkomend scenario bekijken: u schrijft een service en er ontbreekt een methode halverwege de klasse.
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,
)
De suffix doet het zware werk wat betreft context. Door delete_user te zien, leert Codestral drie dingen: de klasse bevraagt de database via self.db.execute, gebruikt geparametriseerde queries met ?, en retourneert het resultaat direct zonder tussenlaag. Het concludeert dat get_user exact hetzelfde patroon moet volgen en genereert:
return self.db.execute("SELECT * FROM users WHERE id = ?", (user_id,))
Probeer de oefening nogmaals zonder de suffix; u zult het verschil merken. Zonder dit anker zal het model vaak een ORM of een cursor verzinnen die nergens in uw project bestaat.
FIM versus Chat: het juiste gereedschap kiezen
| Situatie | Endpoint | Waarom |
|---|---|---|
| Automatisch aanvullen in een IDE | FIM | Context vóór én na de cursor is beschikbaar |
| Genereren van een complete functie | Chat | Geen suffix nodig |
| Aanvullen van een configuratiebestand | FIM | Bestaande indeling en structuur sturen de completion |
| Code uitleggen | Chat | Taak in natuurlijke taal, geen completion |
| Schrijven van unit-tests | Chat of FIM | FIM als het testbestand al gedeeltelijk bestaat |
FIM optimaal benutten
De kwaliteit van de completion hangt in de eerste plaats af van de context die u verstrekt. Neem imports, de ouderklasse en naburige functies op in de prompt. Deze vertellen het model welke bibliotheken beschikbaar zijn en welke stijl het moet hanteren. De suffix verdient speciale aandacht, want zonder daarvan vervalt FIM tot standaardgeneratie en verliest het zijn waarde.
Wat de instellingen betreft, werkt automatisch aanvullen in een IDE het beste met temperature=0, zodat dezelfde situatie altijd hetzelfde voorstel oplevert. Een ontwikkelaar die ziet dat het voorstel bij elke aanslag verandert, zal het uiteindelijk uitschakelen. Houd max_tokens laag, tussen 50 en 200, omdat u een regel of een blok aanvult en niet een volledige module. Tot slot voorkomen stop-tokens overloop: stop=["\n\n"] stopt de generatie aan het einde van het huidige blok in plaats van het model de helft van het bestand te laten herschrijven.
Belangrijkste punten
- FIM vult code aan tussen een prompt (ervoor) en een suffix (erna)
- Het specifieke endpoint is
/v1/fim/completions - Het resultaat is: prompt + completion + suffix = complete code
- De suffix is essentieel voor hoogwaardige contextuele completions
- Gebruik
temperature=0en tokenlimieten voor automatisch aanvullen in IDE’s