Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Implementér citationer i Python

Lektion 9 af 16 Opdateret 3. november 2026 Avanceret
På denne side
  1. Den komplette citations-pipeline
  2. Definér modelkontrakten i systembeskeden
  3. Deklarér søgeværktøjet
  4. Returnér resultater i referenceformat
  5. Adskil tekst fra referencer
  6. Forbered visning i frontend
  7. Vigtige pointer

Opdateret 3. november 2026 baseret på Mistral-guiden Citations & References: værktøjsresultatet følger det dokumenterede format – et objekt indekseret efter kilde-nummer, uden felterne type eller reference_id – og reference_ids i svaret opløses via str(ref_id) inden for dette objekt. Kilde: Citations & References.

Den komplette citations-pipeline

Du skal nu samle en RAG-pipeline, der citerer sine kilder, fra det første API-kald til den datastruktur, dit interface bruger. Hold dette princip fast i tankerne: Modellen henter aldrig dokumenter selv. Den signalerer, at den har brug for en søgning; du udfører søgningen i din egen database, og derefter returnerer du uddragene sammen med deres identifikatorer. Dette frem og tilbage producerer et svar, hvor hvert udsagn forbliver knyttet til et ægte dokument.

Konkret kræver en fuld cyklus to kald til chat.complete. Det første udløser værktøjskaldet; det andet genererer det citerede svar, når kilderne er indsat i historikken. Vi vil gennemgå denne cyklus ved hjælp af et simpelt tilfælde: en intern dokumentationsassistent, der bliver spurgt om bedste praksis for at deploye en LLM.

Definér modelkontrakten i systembeskeden

Systembeskeden fastlægger kontrakten: svar baseret på de leverede kilder, citér systematisk, og frem for alt, indrøm når information mangler, i stedet for at fylde hullet. Denne sidste instruktion gør forskellen i produktion, fordi svar har tendens til at drive af sporet ved spørgsmål, der er dårligt dækket af dokumentationsbasen.

from mistralai.client import Mistral
import json

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

# Systembesked, der opfordrer til citationer
system_message = {
    "role": "system",
    "content": (
        "Du er en dokumentationsassistent. "
        "Besvar spørgsmål ved hjælp af de leverede kilder. "
        "Citér dine kilder systematisk. "
        "Hvis informationen ikke findes i nogen kilde, skal du angive dette eksplicit."
    )
}

user_message = {
    "role": "user",
    "content": "Hvad er bedste praksis for at deploye en LLM i produktion?"
}

messages = [system_message, user_message]

Deklarér søgeværktøjet

Værktøjet beskriver, hvordan en dokumentsøgning ser ud i dit system: her en simpel search_documentation-funktion, der tager et tekstspørgsmål. Det første kald forventer ikke et skriftligt svar; det forventer, at modellen formulerer det spørgsmål, den finder relevant, hvilket sparer dig for at skrive et omskrivningslag.

reference_tool = {
    "type": "function",
    "function": {
        "name": "search_documentation",
        "description": "Søger i dokumentationsdatabasen",
        "parameters": {
            "type": "object",
            "properties": {
                "query": {
                    "type": "string",
                    "description": "Søgeforespørgsel"
                }
            },
            "required": ["query"]
        }
    }
}

# Første kald: Modellen anmoder om at bruge værktøjet
response = client.chat.complete(
    model="mistral-large-latest",
    messages=messages,
    tools=[reference_tool]
)

Returnér resultater i referenceformat

Dette er det strukturelle skridt. Resultaterne fra din søgemaskine kommer tilbage i en ToolMessage, hvis indhold er referenceobjektet fra den tidligere lektion: hver kilde har et nummer ("0", "1"…), en URL, en titel og de valgte uddrag. Det er disse numre, modellen genbruger til at markere sine citationer, og som dit frontend senere vil opløse til links.

from mistralai.client.models import ToolMessage

# Resultater af dokumentsøgning i Mistral-referenceformat
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"
    }
}

# Tilføj værktøjskaldet og svaret til historikken
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)
    )
)

Bemærk, at modellens oprindelige besked genindsættes i historikken før ToolMessage: uden dette par af værktøjskald/værktøjsresultat vil API’et nægte fortsættelsen. Det andet kald behøver ikke længere værktøjsdefinitionerne, da søgningen allerede er udført.

# Andet kald: Modellen genererer et svar med citationer
final_response = client.chat.complete(
    model="mistral-large-latest",
    messages=messages
)

Adskil tekst fra referencer

Det citerede svar er ikke længere en simpel streng, men en sekvens af bidder, der veksler mellem prosa og citationsmarkører. Parsing indebærer at traversere denne sekvens og sortere: TextChunk-objekter rekonstruerer den læsbare tekst, mens ReferenceChunk-objekter leverer de faktisk brugte reference_ids. Denne sondring giver dig værdifuld information: præcis hvilke kilder modellen brugte blandt dem, du leverede.

from mistralai.client.models import TextChunk, ReferenceChunk

def parse_cited_response(response):
    """Udtrækker tekst og referencer fra et citeret svar."""
    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("=== Svar ===")
print(result["text"])
print("\n=== Citerede kilder ===")
for ref_id in result["references_used"]:
    source = references[str(ref_id)]
    print(f"  - {source['title']} : {source['url']}")

Forbered visning i frontend

At flade svaret ud til almindelig tekst ville miste placeringen af citationerne og dermed deres værdi. Det er bedre at beholde sekvensen og berige den: opløs hver ReferenceChunk mod en referencetabel for at medtage titel og URL for hver kilde. Dit interface modtager dermed en sorteret liste over blokke, det kan gengive som klikbare links, tooltips eller interaktive citationsnumre, uden nogensinde at skulle fortolke teksten på ny.

def format_for_frontend(response, reference_map):
    """Formaterer svaret med citationer til 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

Før du åbner denne pipeline for din fulde dokumentationsbase, så kør den med blot tre til fem kilder, som i eksemplet ovenfor. Du vil straks se, om modellen citerer på det rette sted, om den udnytter flere dokumenter, eller om den systematisk klamrer sig til den første, hvilket giver dig mulighed for at korrigere systembeskeden, før adfærden går tabt i mængden.

Vigtige pointer

  • Pipelinen følger et to-trins flow: værktøjskald efterfulgt af citeret svar
  • Referencer sendes via ToolMessage i et objekt indekseret efter kilde-nummer ("0", "1"…)
  • Svaret indeholder en blanding af TextChunk og ReferenceChunk, der skal parses
  • Strukturér outputtet, så dit frontend kan vise interaktive citationer
  • Test med 3–5 kilder for at validere adfærden, før du går i produktion