Retrieval og generation
På denne side
Fra vektor til svar
Du ved nu, hvordan man indekserer dokumenter og henter dem, der ligger tættest på et spørgsmål. Der mangler kun ét skridt: at omdanne en liste over tekststykker (chunks) til et læsbart svar. Det handler om at indsætte den hentede kontekst i en prompt, så LLM’en formulerer et svar baseret på dine data frem for sine træningsdata. Det kræver kun få linjer kode, men det gør en afgørende forskel for kvaliteten. En velpræsenteret kontekst og en klar instruktion er lige så vigtige som præcisionen i selve hentningen.
Opbygning af RAG-prompts
Prompt-strukturen er enkel, men hvert valg har konsekvenser. Nummerér tekststykkerne og forsyn dem med kildeangivelse, så modellen kan citere præcist. Adskil dem med et synligt skilletegn, ---, så modellen ikke fletter to modstridende dokumenter sammen til én påstand. Vigtigst af alt skal instruktionen eksplicit begrænse svaret til den leverede kontekst og give modellen lov til at sige, at den ikke ved noget. Uden denne tilladelse vil en LLM, der bliver spurgt om manglende information, fylde hullet med hvad som helst, der virker plausibelt. Det er netop mekanismen bag hallucinationer.
def build_rag_prompt(question, retrieved_chunks):
"""Build the RAG prompt with retrieved context."""
# Format the context
context_parts = []
for i, chunk in enumerate(retrieved_chunks):
source = chunk.get("source", "unknown source")
context_parts.append(f"[Document {i+1} - {source}]\n{chunk['text']}")
context = "\n\n---\n\n".join(context_parts)
prompt = f"""You are an expert assistant. Answer the question using
ONLY the context provided below. If the information is not in the
context, say so clearly.
## Context
{context}
## Question
{question}
## Answer"""
return prompt
Generering af svaret
Genereringskaldet er ligetil: en systembesked, der gentager rollen, og en brugerbesked, der indeholder den samlede prompt. Hold øje med parameteret temperature, som her er sat til 0,1. Ved kreativ skrivning ønsker du variation; ved RAG ønsker du det modsatte. Du vil have, at modellen holder sig så tæt som muligt på, hvad konteksten siger, og du vil have, at to kørsler på samme spørgsmål giver det samme svar. En høj temperatur ville presse modellen til at omformulere, ekstrapolere og drive væk fra kilden.
from mistralai.client import Mistral
client = Mistral(api_key=api_key)
def generate_answer(question, retrieved_chunks, model="mistral-large-latest"):
"""Generate a RAG answer with Mistral."""
prompt = build_rag_prompt(question, retrieved_chunks)
response = client.chat.complete(
model=model,
messages=[
{
"role": "system",
"content": "You are a precise assistant that answers based on the provided context."
},
{
"role": "user",
"content": prompt,
}
],
temperature=0.1, # Low temperature for factual answers
)
return response.choices[0].message.content
# Example
question = "What are the main steps of RAG?"
results = search_index(question, index, chunks, k=3)
answer = generate_answer(question, results)
print(answer)
Indkapsling af flowet i en klasse
Spredte funktioner fungerer til udforskning, ikke til levering. Klassen RAGPipeline samler tilstanden – tekststykkerne, embeddings-matricen og FAISS-indekset, der bygges én gang ved instansiering – samt tre operationer: retrieve encoder spørgsmålet og spørger indekset, generate samler prompten og kalder modellen, og ask kæder de to sammen. Bemærk, hvad ask returnerer: ikke en streng, men en ordbog, der indeholder svaret, listen over kilder og antallet af anvendte tekststykker. Denne sporbarhed er det, der adskiller en reviderbar assistent fra en black box. Den dag en bruger udfordrer et svar, vil du vide, hvilke passager det byggede på.
import numpy as np
import faiss
from mistralai.client import Mistral
client = Mistral(api_key=api_key)
class RAGPipeline:
"""Complete RAG pipeline with Mistral and FAISS."""
def __init__(self, chunks, embeddings):
self.chunks = chunks
self.embeddings = embeddings.astype(np.float32)
# Create the FAISS index
dimension = embeddings.shape[1]
self.index = faiss.IndexFlatL2(dimension)
self.index.add(self.embeddings)
def retrieve(self, question, k=3):
"""Step 1: retrieve relevant chunks."""
response = client.embeddings.create(
model="mistral-embed",
inputs=[question],
)
query_vector = np.array(
[response.data[0].embedding], dtype=np.float32
)
distances, indices = self.index.search(query_vector, k)
results = []
for dist, idx in zip(distances[0], indices[0]):
if idx >= 0:
results.append({
"text": self.chunks[idx]["text"],
"source": self.chunks[idx].get("source", ""),
"distance": float(dist),
})
return results
def generate(self, question, context_chunks):
"""Step 2: generate the answer with context."""
prompt = build_rag_prompt(question, context_chunks)
response = client.chat.complete(
model="mistral-large-latest",
messages=[{"role": "user", "content": prompt}],
temperature=0.1,
)
return response.choices[0].message.content
def ask(self, question, k=3):
"""Full pipeline: question -> sourced answer."""
# Retrieval
context = self.retrieve(question, k=k)
# Generation
answer = self.generate(question, context)
return {
"question": question,
"answer": answer,
"sources": [c["source"] for c in context],
"n_chunks_used": len(context),
}
# Usage
rag = RAGPipeline(chunks, embeddings)
result = rag.ask("How does indexing work in FAISS?")
print(f"Question: {result['question']}")
print(f"Answer: {result['answer']}")
print(f"Sources: {result['sources']}")
Tre prompt-varianter efter brugssituation
Du kan specialisere basis-prompts afhængigt af, hvad du forventer af assistenten. Hvis dine brugere skal verificere hver eneste påstand, skal du eksplicit bede om citationer i klammer. Modellen knytter derefter hver sætning til et nummereret dokument. Hvis svaret skal ind i en grænseflade eller en rapport, sikrer et struktureret format stabile sektioner: et koncist svar, detaljer, kilder og et konfidensniveau, der afspejler, hvor godt konteksten dækker spørgsmålet. Den tredje variant spiller en anden rolle: den lærer modellen at nedbryde usikkerhed ved at skelne mellem, hvad den kan hævde med sikkerhed, hvad der mangler, og hvor man skal lede videre. Dette giver ofte de mest nyttige assistenter i praksis, fordi „Jeg mangler X” er bedre end et selvsikkert, men forkert svar.
# 1. Prompt with citation instruction
prompt_cite = """Answer by citing source documents in brackets.
Example: "RAG improves accuracy [Document 1]."
Context: {context}
Question: {question}"""
# 2. Prompt with structured format
prompt_structured = """Answer in the following format:
**Answer**: [your concise answer]
**Details**: [detailed explanation]
**Sources**: [list of documents used]
**Confidence**: [high/medium/low based on context coverage]
Context: {context}
Question: {question}"""
# 3. Prompt with missing-information handling
prompt_honest = """If the context does not contain enough information to
answer completely, state clearly:
- What you can assert with certainty
- What is missing from the context
- Suggestions for obtaining the missing information
Context: {context}
Question: {question}"""
På siden med kaldsparametre styrer tre indstillinger RAG-adfærden. En lav temperatur låser det faktuelle output fast, max_tokens forhindrer svar, der driver ud i essays, og en konservativ top_p begrænser det sampled ordforråd til de mest sandsynlige fortsættelser.
# For RAG, use a low temperature
response = client.chat.complete(
model="mistral-large-latest",
messages=[{"role": "user", "content": prompt}],
temperature=0.1, # Factual, low creativity
max_tokens=1024, # Limit answer length
top_p=0.95, # Conservative nucleus sampling
)
Vigtige pointer
- RAG-prompts indsætter hentet kontekst før spørgsmålet
- Brug en lav temperatur (0,1–0,3) til faktuelle svar
- Bed modellen om at citere kilder for at sikre sporbarhed
- Klassen
RAGPipelineindkapsler hele flowet: retrieve, generate, ask - Håndtér tilfælde, hvor konteksten mangler tilstrækkelig information