Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Best Practices en Productie

Les 14 van 14 Bijgewerkt op 29 juli 2026 Ontwikkelaar
Op deze pagina
  1. Van Proof of Concept naar Productie
  2. Implementatiechecklist
  3. Beschrijvingen schrijven die het model laten werken
  4. Het juiste model kiezen
  5. Het systeembericht structureren
  6. Kosten beheren in productie
  7. Function Calling testen
  8. Monitoring in productie
  9. Volgende stappen
  10. Belangrijkste punten
  11. Test uw kennis

Van Proof of Concept naar Productie

U beschikt nu over alle bouwstenen om function calling-systemen met Mistral te construeren. Wat uw prototype scheidt van een productieklaar service, zijn geen ontbrekende functies, maar een reeks controles en afstemmingsstappen die u doorgaans ontdekt tijdens een incident. Deze laatste les brengt best practices, valkuilen en een checklist samen om met vertrouwen naar productie te gaan.

Implementatiechecklist

Dit is de enige plek in deze cursus waar een lijstformaat verplicht is: voordat u live gaat, vinkt u vakjes aan. Vier domeinen moeten worden gedekt, die elk een andere vraag beantwoorden.

Architectuur zorgt ervoor dat de mechanica standhoudt. Het teruggeven van JSON-strings in de keten en het hebben van een compleet dispatch-woordenboek zijn de twee meest voorkomende oorzaken van crashes bij de eerste echte oproep.

  • Alle functies geven JSON-strings terug (nooit ruwe Python-objecten)
  • Het dispatch-woordenboek is compleet en up-to-date
  • Functies behandelen foutgevallen en geven bruikbare berichten terug
  • Het systeembericht is duidelijk, precies en getest
  • De conversatielus behandelt sequentiële en parallelle oproepen

Beveiliging gaat ervan uit dat argumenten van een gebruiker komen, nooit van uw applicatie.

  • Argumenten worden gevalideerd voordat ze worden uitgevoerd (formaat, type, waarden)
  • SQL-query’s gebruiken parameters (geen concatenatie)
  • Een whitelist beperkt de beschikbare functies
  • Destructieve acties vereisen bevestiging
  • Rate limiting is ingesteld per functie en per gebruiker
  • Resultaten worden gesaneerd (geen gevoelige data teruggegeven aan het model)

Betrouwbaarheid handelt af wat er misgaat zonder dat iemand schuld heeft.

  • Fouten worden in een gestructureerd formaat aan het model teruggegeven
  • Retry met backoff is geïmplementeerd voor tijdelijke fouten
  • Time-outs zijn geconfigureerd voor elke externe functie
  • De geschiedenisgrootte is beperkt om token-overschrijdingen te voorkomen

Monitoring, tot slot, is wat u in staat stelt diagnoses te stellen zonder te gokken.

  • Elke functieaanroep wordt gelogd (naam, argumenten, resultaat, duur)
  • Fouten triggeren alerts (Slack, PagerDuty, etc.)
  • Metrieken worden verzameld (slaagpercentage, latentie, API-kosten)

Beschrijvingen schrijven die het model laten werken

De kwaliteit van beschrijvingen heeft een directe impact op de nauwkeurigheid, en het is vaak de goedkoopste hefboom om aan te halen. Drie patronen keren terug bij teams met hoge percentages correcte oproepen. Het eerste verankert de beschrijving in de bedrijfscontext: in plaats van de functienaam te parafraseren, somt u mogelijke retourwaarden op en geeft u expliciet aan wanneer de functie moet worden aangeroepen. Het tweede sluipt formaatvoorbeelden in de parameterbeschrijving, wat de meeste ID-extractiefouten oplost. Het derde vervangt een instructie in natuurlijke taal door een enum, de enige manier om een waarde buiten de lijst echt te verbieden.

# Patroon 1: Beschrijving met bedrijfscontext
{
    "description": "Haalt betalingsstatus op. "
                   "Mogelijke statussen: paid, pending, failed, refunded. "
                   "Gebruik deze functie wanneer de gebruiker vraagt "
                   "naar de status van een betaling of whether it was received."
}

# Patroon 2: Parameters met voorbeelden
{
    "transaction_id": {
        "type": "string",
        "description": "Unieke ID in formaat T gevolgd door 4 cijfers (bijv. T1001, T2345)"
    }
}

# Patroon 3: Enum voor beperkte waarden
{
    "status": {
        "type": "string",
        "enum": ["paid", "pending", "failed", "refunded"],
        "description": "Filter op betalingsstatus"
    }
}

Het juiste model kiezen

Modelkeuze is een afweging tussen nauwkeurigheid en kosten, en er is geen universeel antwoord: het hangt af van het aantal blootgestelde functies en de complexiteit van hun schema’s. Een complexe casus met veel functies en geneste parameters rechtvaardigt Mistral Large 3, dat betrouwbaarder is bij functiekeuze maar duurder. Een standaardcasus met enkele eenvoudige functies in productie met hoge doorvoer draait zeer goed op Mistral Small 4, dat snel en zuinig is. Voor prototyping en testen biedt Mistral Medium 3.5 een goed compromis.

# Complexe gevallen: veel functies, geneste parameters
# -> Mistral Large 3 (betrouwbaarder, duurder)
model = "mistral-large-latest"

# Standaardgevallen: weinig eenvoudige functies, productie met hoge doorvoer
# -> Mistral Small 4 (snel, zuinig)
model = "mistral-small-latest"

# Ontwikkelingsgevallen: prototyping, testen
# -> Mistral Medium 3.5 (goed compromis)
model = "mistral-medium-latest"

De methode is net zo belangrijk als het resultaat: begin in productie met het meest capabele model, meet uw percentage correcte oproepen en stap dan geleidelijk af om de beste kosten/prestatieverhouding te vinden. Het omgekeerde—beginnen met het goedkoopste model—ontneemt u de basislijn die nodig is om te weten of degradatie komt door het model of uw beschrijvingen.

Het systeembericht structureren

Een goed systeembericht maakt het verschil tussen een matige assistent en een uitstekende. Dit illustreert een bewezen structuur: een rolstatement, een blok met imperatieve regels, gevolgd door een herinnering aan de beschikbare tools. De twee kosteneffectiefste regels hier zijn “Als de gebruiker geen vereiste ID verstrekt, vraag dan beleefd” en “Raad nooit een transactie-ID”—samen elimineren ze het meest schadelijke gedrag van allemaal: het aanroepen van een functie met een verzonnen ID.

system_message = {
    "role": "system",
    "content": """You are a payment management assistant for Acme Corporation.

Rules:
- Always respond in English
- Format amounts in euros with the symbol and 2 decimal places
- If the user doesn't provide a required ID, ask politely
- Never guess a transaction ID
- When a transaction fails, offer to check the details

Available tools:
- retrieve_payment_status: to check a payment's status
- retrieve_payment_date: to check a payment's date
- retrieve_payment_details: to get all details of a transaction
- list_customer_transactions: to view all transactions for a customer"""
}

Kosten beheren in productie

Elke function calling-oproep verbruikt tokens, en de rekening loopt op via twee onderschatte kanalen: tool-definities worden bij elk verzoek meegestuurd, en de geschiedenis groeit bij elke beurt. Het filteren van functies op context lost het eerste punt op—het is niet nodig om alle twaalf tools te sturen wanneer de vraag duidelijk over betalingen gaat. Het afkappen van de geschiedenis voorbij een drempelwaarde lost het tweede op. En wanneer alle benodigde data al in de context zit, vermijdt tool_choice="none" een extra round trip.

# 1. Beperk het aantal functies per verzoek
# Geef alleen functies door die relevant zijn voor de context
def get_relevant_tools(user_input: str, all_tools: list) -> list:
    """Filtert tools op basis van context."""
    if "payment" in user_input.lower() or "transaction" in user_input.lower():
        return [t for t in all_tools if "payment" in t["function"]["name"]]
    if "contact" in user_input.lower() or "customer" in user_input.lower():
        return [t for t in all_tools if "contact" in t["function"]["name"]]
    return all_tools

# 2. Beperk de grootte van de geschiedenis
MAX_HISTORY = 20  # berichten

# 3. Gebruik tool_choice="none" wanneer data al beschikbaar is

Function Calling testen

Tests zijn essentieel om regressies te voorkomen, en hier richten ze zich op een ongebruikelijk object: u controleert niet de retourwaarde van uw functie, maar de beslissing van het model. Twee testfamilies dekken de essentie. De eerste verifieert dat een zakelijke vraag de juiste functie activeert met de juiste geëxtraheerde argumenten. De tweede, even belangrijk en vaak vergeten, verifieert dat een begroeting geen oproep activeert—deze test vangt te brede beschrijvingen die het model ertoe aanzetten om in elke omstandigheid een functie aan te roepen.

def test_payment_status():
    """Test dat het model de juiste functie aanroept."""
    messages = [{"role": "user", "content": "Status of payment T1001?"}]

    response = client.chat.complete(
        model=model, messages=messages, tools=tools
    )

    message = response.choices[0].message
    assert message.tool_calls is not None
    assert len(message.tool_calls) == 1
    assert message.tool_calls[0].function.name == "retrieve_payment_status"

    args = json.loads(message.tool_calls[0].function.arguments)
    assert args["transaction_id"] == "T1001"


def test_no_function_for_greeting():
    """Test dat het model geen functie aanroept voor een begroeting."""
    messages = [{"role": "user", "content": "Hello!"}]

    response = client.chat.complete(
        model=model, messages=messages, tools=tools
    )

    message = response.choices[0].message
    assert message.tool_calls is None or len(message.tool_calls) == 0
    assert message.content is not None

Monitoring in productie

Nu moet u weten wat uw systeem doet zodra het in het wild is vrijgelaten. De onderstaande klasse aggregeert drie signalen die samen bijna het hele verhaal vertellen: algemeen slaagpercentage, gemiddelde latentie en uitsplitsing per functie. Die laatste is in de praktijk het meest veelzeggend—een functie waarvan de foutenteller geïsoleerd afwijkt, wijst op een specifiek probleem, terwijl een verslechterd algemeen percentage u niets vertelt over waar u moet kijken.

import time
import logging

logger = logging.getLogger("fc_monitor")

class FunctionCallingMonitor:
    def __init__(self):
        self.metrics = {
            "total_calls": 0,
            "successful_calls": 0,
            "failed_calls": 0,
            "total_latency_ms": 0,
            "calls_by_function": {}
        }

    def record(self, function_name: str, success: bool, latency_ms: float):
        self.metrics["total_calls"] += 1
        self.metrics["total_latency_ms"] += latency_ms

        if success:
            self.metrics["successful_calls"] += 1
        else:
            self.metrics["failed_calls"] += 1

        if function_name not in self.metrics["calls_by_function"]:
            self.metrics["calls_by_function"][function_name] = {
                "count": 0, "errors": 0
            }
        self.metrics["calls_by_function"][function_name]["count"] += 1
        if not success:
            self.metrics["calls_by_function"][function_name]["errors"] += 1

    def get_success_rate(self) -> float:
        if self.metrics["total_calls"] == 0:
            return 0.0
        return self.metrics["successful_calls"] / self.metrics["total_calls"]

    def get_avg_latency(self) -> float:
        if self.metrics["total_calls"] == 0:
            return 0.0
        return self.metrics["total_latency_ms"] / self.metrics["total_calls"]

monitor = FunctionCallingMonitor()

Volgende stappen

Nu u function calling met Mistral onder de knie heeft, gaan er verschillende richtingen open. De meest natuurlijke is het bouwen van autonome agenten, waarbij function calling wordt gecombineerd met een agent-lus die complexe taken plant en uitvoert; de Mistral Agents API en zijn client.beta.agents.create() gaan verder door persistente agenten met state aan te bieden. Een andere as combineert RAG en function calling: het model beslist zelf wanneer het een vectordatabase moet bevragen, in plaats van dat zoeken systematisch upstream wordt getriggerd. Aan de kant van de gebruikerservaring laat streaming u reacties in real-time weergeven terwijl functies worden uitgevoerd, wat de perceptie van latentie bij lange oproepketens verandert. Tot slot opent multimodaal function calling voor visie voor documentanalyse.

Belangrijkste punten

  • De implementatiechecklist dekt architectuur, beveiliging, betrouwbaarheid en monitoring
  • Precieze beschrijvingen met voorbeelden en enums verbeteren de nauwkeurigheid van het model
  • Kies het juiste model op basis van complexiteit en budget (Large voor betrouwbaarheid, Small voor doorvoer)
  • Het systeembericht is een krachtige hefboom om gedrag te sturen
  • Test functieaanroepen en gedrag zonder functie systematisch
  • Monitor slaagpercentage, latentie en kosten in productie

Test uw kennis

End-to-end function calling: vijf controles.

1. Wat zijn de vijf stappen van function calling?

Antwoord: Functies definiëren (schema’s), ze aan de API leveren, het model vraagt een oproep aan met zijn argumenten, uw code voert uit en geeft het resultaat terug, het model produceert de definitieve respons.

2. Wat maakt een goed functieschema?

Antwoord: Strikte types en operationele beschrijvingen—duidelijke naam, wanneer deze te gebruiken, formaat van elke parameter: dit is de tekst die het model leest om te beslissen en in te vullen.

3. Wat maken parallelle oproepen mogelijk?

Antwoord: Het model vraagt meerdere functies aan in één enkele respons wanneer ze onafhankelijk zijn—minder round trips, op voorwaarde dat u elk resultaat koppelt aan zijn oproep.

4. Waar dient tool_choice voor?

Antwoord: Om de vrijheid van het model in te stellen: auto (het beslist), any (het moet een tool gebruiken), of een geforceerde tool—de laatste is sleutel tot betrouwbare gestructureerde extractie.

5. Welke beveiligingsregels voor blootgestelde functies?

Antwoord: Valideer ontvangen argumenten, beperk de scope van elke functie, log oproepen, en houd menselijke validatie op het vastleggen van acties—het model stelt voor, uw code beschikt.

De twee uitgewerkte voorbeelden in deze cursus (payment tracker, CRM) passen exact deze regels toe—uw eigen integraties zullen dezelfde mal volgen.