Siirry pääsisältöön
Suomi— Valitse kieli
Valikko

Haku ja generointi

Oppitunti 13 / 18 Päivitetty 2. marraskuuta 2026 Kehittäjä
Tällä sivulla
  1. Vektorista vastaukseen
  2. RAG-kehotteen rakentaminen
  3. Vastauksen generointi
  4. Vuon kapselointi luokkaan
  5. Kolme kehotemuunnelmaa käyttötarkoituksen mukaan
  6. Keskeiset asiat

Vektorista vastaukseen

Osaat jo indeksoida dokumentteja ja hakea kysymystä lähimmät tulokset. Jäljellä on yksi askel: muuttaa chunkkien lista luettavaksi vastaukseksi. Tämä tarkoittaa haetun kontekstin syöttämistä kehotteeseen, jotta suurkielimalli (LLM) muotoilee vastauksen datasi pohjalta eikä harjoitusmuistiensa perusteella. Se vaatii vain muutaman koodirivin, mutta tekee ratkaisevan eron laatuun. Hyvin esitetty konteksti ja selkeä ohjeistus ovat yhtä tärkeitä kuin haun tarkkuus.

RAG-kehotteen rakentaminen

Kehotteen rakenne on yksinkertainen, mutta jokaisella valinnalla on seurauksensa. Numeroi chunkit ja merkitse niiden lähde, jotta malli voi viitata niihin tarkasti. Erota ne näkyvällä erottimella ---, jotta malli ei yhdistä kahta ristiriitaista dokumenttia yhdeksi väittämäksi. Tärkeintä on, että ohjeistus rajoittaa vastauksen nimenomaan annettuun kontekstiin ja sallii mallin sanoa, ettei se tiedä. Ilman tätä lupaa LLM täyttää puuttuvan tiedon millä tahansa uskottavalta näyttävällä. Juuri tämä on hallusinaation mekanismi.

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

Vastauksen generointi

Generointikutsu on suoraviivainen: järjestelmäviesti, joka toistaa roolin, ja käyttäjäviesti, joka sisältää koostetun kehotteen. Kiinnitä huomiota lämpötilaparametriin, joka on tässä asetettu arvoon 0.1. Luovassa kirjoittamisessa haluat vaihtelua; RAG:ssa haluat päinvastaista. Haluat mallin pysyvän mahdollisimman lähellä sitä, mitä kontekstissa sanotaan, ja haluat kahden ajon samalla kysymyksellä tuottavan saman vastauksen. Korkea lämpötila pakottaisi mallin muotoilemaan uudelleen, ekstrapoloimaan ja ajautumaan kauemmaksi lähteestä.

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)

Vuon kapselointi luokkaan

Hajautetut funktiot sopivat tutkimukseen, eivät tuotantoon. RAGPipeline-luokka niputtaa tilan – chunkit, upotusmatriisin ja kerran alustuksessa rakennetun FAISS-indeksin – sekä kolme operaatiota: retrieve koodaa kysymyksen ja hakee indeksistä, generate kokoaa kehotteen ja kutsuu mallia, ja ask ketjuttaa nämä kaksi. Huomaa, mitä ask palauttaa: ei merkkijonoa, vaan sanakirjan, joka sisältää vastauksen, lähteiden listan ja käytettyjen chunkkien määrän. Tämä jäljitettävyys erottaa auditoitavan avustajan mustasta laatikosta. Sinä päivänä, kun käyttäjä kyseenalaistaa vastauksen, tiedät, mihin kohtiin se perustui.

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']}")

Kolme kehotemuunnelmaa käyttötarkoituksen mukaan

Voit erikoistaa peruskehotteen sen mukaan, mitä odotat avustajalta. Jos käyttäjiesi on varmistettava jokainen väittämä, pyydä nimenomaisesti viittauksia hakasulkeisiin. Malli liittää tällöin jokaisen lauseen numeroituun dokumenttiin. Jos vastaus syötetään käyttöliittymään tai raporttiin, jäsennelty muoto pakottaa vakaat osiot: tiivis vastaus, yksityiskohdat, lähteet ja luottamustaso, joka heijastaa sitä, kuinka hyvin konteksti kattaa kysymyksen. Kolmas muunnelma toimii eri tavalla: se opettaa mallia purkamaan epävarmuutta erottamalla sen, mitä se voi väittää varmasti, mitä puuttuu ja mistä etsiä lisää. Tämä tuottaa usein käytännössä hyödyllisimmät avustajat, koska “minulta puuttuu X” on parempi kuin varma mutta väärä vastaus.

# 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}"""

Kutsuparametrien osalta kolme asetusta ohjaa RAG:n toimintaa. Matala lämpötila lukitsee faktapohjaisen tulosteen, max_tokens estää vastauksia ajautumasta esseiksi, ja konservatiivinen top_p rajoittaa otetun sanaston todennäköisimpiin jatko-osuuksiin.

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

Keskeiset asiat

  • RAG-kehote syöttää haetun kontekstin ennen kysymystä
  • Käytä matalaa lämpötilaa (0.1–0.3) faktapohjaisiin vastauksiin
  • Pyydä mallia viittaamaan lähteisiin jäljitettävyyden vuoksi
  • RAGPipeline-luokka kapseloi koko vuon: haku, generointi, kysyminen
  • Huomioi tapaukset, joissa kontekstista puuttuu riittävästi tietoa