Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Implementeer citaties in Python

Les 9 van 16 Bijgewerkt op 3 november 2026 Gevorderd
Op deze pagina
  1. De volledige citatiepijplijn
  2. Definieer het modelcontract in het systeembericht
  3. Declareer de zoektool
  4. Resultaten retourneren in referentieformaat
  5. Scheid tekst van referenties
  6. Bereid de weergave in de frontend voor
  7. Belangrijkste punten

Bijgewerkt op 3 november 2026 op basis van de Mistral-gids Citations & References: het tool-resultaat volgt het gedocumenteerde formaat—een object geïndexeerd op bronnummer, zonder velden type of reference_id—en de reference_ids in het antwoord worden opgelost via str(ref_id) binnen dat object. Bron: Citations & References.

De volledige citatiepijplijn

U gaat nu een RAG-pijplijn samenstellen die zijn bronnen citeert, van de eerste API-aanroep tot de gegevensstructuur die uw interface verbruikt. Houd dit principe voor ogen: het model haalt nooit zelf documenten op. Het geeft aan dat het een zoekopdracht nodig heeft, u voert die zoekopdracht uit in uw eigen database en vervolgens retourneert u de fragmenten samen met hun identificatiecodes. Deze wisselwerking produceert een antwoord waarin elke bewering gekoppeld blijft aan een echt document.

Specifiek vereist een volledige cyclus twee aanroepen van chat.complete. De eerste activeert de tool-aanroep; de tweede genereert het geciteerde antwoord zodra de bronnen in de geschiedenis zijn geïnjecteerd. We lopen deze cyclus door aan de hand van een eenvoudig geval: een interne documentatie-assistent die wordt gevraagd naar best practices voor het implementeren van een LLM.

Definieer het modelcontract in het systeembericht

Het systeembericht stelt het contract: beantwoord vragen op basis van de verstrekte bronnen, citeer systematisch en geef bovenal toe wanneer informatie ontbreekt in plaats van de leemte op te vullen. Deze laatste instructie maakt het verschil in productie, omdat antwoorden de neiging hebben af te dwalen bij vragen die slecht gedekt zijn door de documentatiebasis.

from mistralai.client import Mistral
import json

client = Mistral(api_key="your-api-key")

# Systeembericht dat citaties aanmoedigt
system_message = {
    "role": "system",
    "content": (
        "You are a documentation assistant. "
        "Answer questions using the provided sources. "
        "Cite your sources systematically. "
        "If the information is not in any source, state this explicitly."
    )
}

user_message = {
    "role": "user",
    "content": "What are the best practices for deploying an LLM in production?"
}

messages = [system_message, user_message]

Declareer de zoektool

De tool beschrijft hoe een documentzoekopdracht er in uw systeem uitziet: hier een simpele search_documentation-functie die een tekstquery als argument neemt. De eerste aanroep verwacht geen geschreven antwoord; het verwacht dat het model de query formuleert die het relevant acht, waardoor u een herformuleringslaag bespaart.

reference_tool = {
    "type": "function",
    "function": {
        "name": "search_documentation",
        "description": "Searches the documentation database",
        "parameters": {
            "type": "object",
            "properties": {
                "query": {
                    "type": "string",
                    "description": "Search query"
                }
            },
            "required": ["query"]
        }
    }
}

# Eerste aanroep: het model vraagt om de tool te gebruiken
response = client.chat.complete(
    model="mistral-large-latest",
    messages=messages,
    tools=[reference_tool]
)

Resultaten retourneren in referentieformaat

Dit is de structurele stap. De resultaten van uw zoekmachine komen terug in een ToolMessage waarvan de inhoud het referentieobject uit de vorige les is: elke bron heeft een nummer ("0", "1"…), een URL, een titel en de geselecteerde fragmenten. Dit zijn de nummers die het model hergebruikt om zijn citaties te markeren en die uw frontend later zal omzetten in links.

from mistralai.client.models import ToolMessage

# Resultaten van documentatiezoekopdracht, in Mistral-referentieformaat
references = {
    "0": {
        "url": "https://docs.example.com/deployment-guide",
        "title": "LLM Deployment Guide",
        "snippets": [[
            "Always configure rate limits to protect the service.",
            "Monitor P99 latency and error rates continuously."
        ]],
        "description": None,
        "date": "2026-09-01",
        "source": "docs"
    },
    "1": {
        "url": "https://docs.example.com/security",
        "title": "AI Application Security",
        "snippets": [[
            "Filter user inputs to prevent injections.",
            "Never expose API keys on the client side."
        ]],
        "description": None,
        "date": "2026-08-15",
        "source": "docs"
    },
    "2": {
        "url": "https://docs.example.com/scaling",
        "title": "Scalability and Performance",
        "snippets": [[
            "Use semantic caching to reduce API calls.",
            "Size instances based on peak traffic."
        ]],
        "description": None,
        "date": "2026-07-20",
        "source": "docs"
    }
}

# Voeg de tool-aanroep en het antwoord toe aan de geschiedenis
tool_call = response.choices[0].message.tool_calls[0]
messages.append(response.choices[0].message)

messages.append(
    ToolMessage(
        tool_call_id=tool_call.id,
        name="search_documentation",
        content=json.dumps(references, ensure_ascii=False)
    )
)

Merk op dat het oorspronkelijke bericht van het model opnieuw in de geschiedenis wordt geïnjecteerd vóór de ToolMessage: zonder dit paar tool-aanroep/tool-resultaat weigert de API de voortzetting. De tweede aanroep heeft de tool-definities niet langer nodig, aangezien de zoekopdracht al heeft plaatsgevonden.

# Tweede aanroep: het model genereert een antwoord met citaties
final_response = client.chat.complete(
    model="mistral-large-latest",
    messages=messages
)

Scheid tekst van referenties

Het geciteerde antwoord is niet langer een simpele string, maar een reeks chunks die proza en citatiemarkeringen afwisselen. Parseren houdt in dat u door deze reeks loopt en sorteert: TextChunk-objecten reconstrueren de leesbare tekst, terwijl ReferenceChunk-objecten de daadwerkelijk gebruikte reference_ids leveren. Dit onderscheid geeft u waardevolle informatie: precies welke bronnen het model heeft gebruikt van degenen die u hebt verstrekt.

from mistralai.client.models import TextChunk, ReferenceChunk

def parse_cited_response(response):
    """Extraheert tekst en referenties uit een geciteerd antwoord."""
    content_parts = response.choices[0].message.content
    text_parts = []
    cited_refs = set()

    for chunk in content_parts:
        if isinstance(chunk, TextChunk):
            text_parts.append(chunk.text)
        elif isinstance(chunk, ReferenceChunk):
            for ref_id in chunk.reference_ids:
                cited_refs.add(ref_id)

    return {
        "text": "".join(text_parts),
        "references_used": list(cited_refs)
    }

result = parse_cited_response(final_response)
print("=== Response ===")
print(result["text"])
print("\n=== Cited Sources ===")
for ref_id in result["references_used"]:
    source = references[str(ref_id)]
    print(f"  - {source['title']} : {source['url']}")

Bereid de weergave in de frontend voor

Het platwalsen van het antwoord tot platte tekst zou de positie van citaties, en dus hun waarde, laten verloren gaan. Het is beter om de reeks te behouden en te verrijken: los elke ReferenceChunk op tegen een referentietabel om de titel en URL van elke bron mee te nemen. Uw interface ontvangt zo een geordende lijst met blokken die het kan weergeven als aanklikbare links, tooltips of interactieve citatienummers, zonder ooit de tekst opnieuw te hoeven interpreteren.

def format_for_frontend(response, reference_map):
    """Formatteert het antwoord met citaties voor de frontend."""
    content_parts = response.choices[0].message.content
    formatted = []

    for chunk in content_parts:
        if isinstance(chunk, TextChunk):
            formatted.append({
                "type": "text",
                "content": chunk.text
            })
        elif isinstance(chunk, ReferenceChunk):
            refs = []
            for ref_id in chunk.reference_ids:
                source = reference_map.get(str(ref_id))
                if source:
                    refs.append({
                        "id": ref_id,
                        "title": source["title"],
                        "url": source["url"]
                    })
            formatted.append({
                "type": "citation",
                "references": refs
            })

    return formatted

Voordat u deze pijplijn opent voor uw volledige documentatiebasis, voert u deze uit met slechts drie tot vijf bronnen, zoals in het bovenstaande voorbeeld. U ziet direct of het model op de juiste plaats citeert, of het meerdere documenten benut, of dat het zich systematisch aan de eerste vastklampt, waardoor u het systeembericht kunt corrigeren voordat het gedrag verloren gaat in de volume.

Belangrijkste punten

  • De pijplijn volgt een flow met twee aanroepen: eerst de tool-aanroep, daarna het geciteerde antwoord
  • Referenties worden doorgegeven via ToolMessage, in een object geïndexeerd op bronnummer ("0", "1"…)
  • Het antwoord bevat een mix van TextChunk en ReferenceChunk om te parseren
  • Structureer de uitvoer zodat uw frontend interactieve citaties kan weergeven
  • Test met 3–5 bronnen om het gedrag te valideren voordat u naar productie gaat