Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Retrieval och generering

Lektion 13 av 18 Uppdaterad 2 november 2026 Utvecklare
På denna sida
  1. Från vektor till svar
  2. Bygga RAG-prompten
  3. Generera svaret
  4. Kapsla in flödet i en klass
  5. Tre promptvarianter beroende på användningsområde
  6. Viktiga punkter

Från vektor till svar

Du vet hur man indexerar dokument och hämtar de som ligger närmast en fråga. Ett steg återstår: att omvandla en lista med textbitar till ett läsbart svar. Det handlar om att injicera den hämtade kontexten i en prompt så att LLM:n formulerar ett svar baserat på dina data snarare än sina träningsminnen. Det krävs bara några rader kod, men det gör en avgörande skillnad för kvaliteten. En väl presenterad kontext och en tydlig instruktion är lika viktiga som precisionen i hämtningen.

Bygga RAG-prompten

Promptens struktur är enkel, men varje val får konsekvenser. Numrera textbitarna och förse dem med källhänvisning så att modellen kan citera exakt. Avgränsa dem med en synlig separator, ---, så att modellen inte slår samman två motstridiga dokument till ett enda påstående. Viktigast av allt: instruktionen måste uttryckligen begränsa svaret till den tillhandahållna kontexten och tillåta modellen att säga att den inte vet. Utan detta tillstånd kommer en LLM som får en fråga om saknad information att fylla gapet med vad som än verkar rimligt. Det är själva mekanismen bakom 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

Generera svaret

Anropet för generering är rakt på sak: ett systemmeddelande som upprepar rollen, och ett användarmeddelande som bär den sammansatta prompten. Håll koll på parametern temperature, som här är satt till 0.1. Vid kreativt skrivande vill du ha variation; vid RAG vill du ha motsatsen. Du vill att modellen ska hålla sig så nära som möjligt till vad kontexten säger, och du vill att två körningar på samma fråga ska ge samma svar. En hög temperatur skulle få modellen att formulera om, extrapolera och driva iväg från källan.

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)

Kapsla in flödet i en klass

Spridda funktioner fungerar för utforskning, inte för leverans. Klassen RAGPipeline buntar ihop tillståndet – textbitarna, inbäddningsmatrisen och FAISS-indexet som byggs en gång vid initiering – samt tre operationer: retrieve kodar frågan och frågar indexet, generate sätter ihop prompten och anropar modellen, och ask kedjar ihop de två. Lägg märke till vad ask returnerar: inte en sträng, utan en ordlista som innehåller svaret, listan över källor och antalet använda textbitar. Denna spårbarhet är vad som skiljer en granskningsbar assistent från en svart låda. Den dag en användare ifrågasätter ett svar kommer du att veta vilka passager det förlitade sig 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 promptvarianter beroende på användningsområde

Du kan specialisera basprompten beroende på vad du förväntar dig av assistenten. Om dina användare måste verifiera varje påstående, be uttryckligen om citat inom klamrar. Modellen kopplar då varje mening till ett numrerat dokument. Om svaret matar ett gränssnitt eller en rapport, tvingar ett strukturerat format fram stabila sektioner: ett koncist svar, detaljer, källor och en konfidensnivå som speglar hur väl kontexten täcker frågan. Den tredje varianten spelar en annan roll: den lär modellen att bryta ner osäkerhet genom att skilja på vad den kan hävda, vad som saknas och var man ska leta härnäst. Detta ger ofta de mest användbara assistenterna i praktiken, eftersom “Jag saknar X” slår ett självsäkert men felaktigt 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}"""

När det gäller anropsparametrar styr tre inställningar RAG-beteendet. En låg temperatur låser fast faktamässiga utdata, max_tokens förhindrar svar som glider över i essäer, och en konservativ top_p begränsar det samplade ordförrådet till de mest sannolika fortsättningarna.

# 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
)

Viktiga punkter

  • RAG-prompten injicerar hämtad kontext före frågan
  • Använd en låg temperatur (0,1–0,3) för faktamässiga svar
  • Be modellen citera källor för spårbarhet
  • Klassen RAGPipeline kapslar in hela flödet: hämta, generera, fråga
  • Hantera fall där kontexten saknar tillräcklig information