Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

Išgavimas ir generavimas

Paskaita 13 iš 18 Atnaujinta 2026 m. lapkričio 2 d. Kūrėjas
Šiame puslapyje
  1. Nuo vektoriaus iki atsakymo
  2. RAG užklausos kūrimas
  3. Atsakymo generavimas
  4. Veiksmo įkapsuliavimas klasėje
  5. Trys užklausų variantai pagal naudojimo atvejį
  6. Svarbiausi punktai

Nuo vektoriaus iki atsakymo

Jau žinai, kaip indeksuoti dokumentus ir išgauti tuos, kurie labiausiai atitinka klausimą. Liko tik vienas žingsnis: paversti fragmentų sąrašą į skaitomą atsakymą. Tai reiškia įterpti gautą kontekstą į užklausą (prompt), kad didysis kalbos modelis (LLM) suformuluotų atsakymą remdamasis tavo duomenimis, o ne savo mokymo atmintimi. Tam užtenka kelių kodo eilučių, tačiau tai lemia esminį kokybės skirtumą. Tinkamai pateiktas kontekstas ir aiški instrukcija yra tokie pat svarbūs kaip ir išgavimo tikslumas.

RAG užklausos kūrimas

Užklausos struktūra paprasta, tačiau kiekvienas pasirinkimas turi pasekmių. Sunumeruok fragmentus ir pridėk jų šaltinį, kad modelis galėtų tiksliai cituoti. Atskirk juos matomu skirtuku ---, kad modelis nesulietų dviejų prieštaraujančių dokumentų į vieną teiginį. Svarbiausia – instrukcijoje turi būti aiškiai nurodyta, jog atsakymas turi remtis TIK pateiktu kontekstu, ir modelis turi turėti leidimą pasakyti, kad nežino atsakymo. Be tokio leidimo LLM, paklaustas apie trūkstamą informaciją, užpildys spragą tuo, kas atrodo tikėtina. Būtent taip ir atsiranda haliucinacijos.

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

Atsakymo generavimas

Generavimo užklausa yra tiesmuka: sistemos žinutė, kuri pakartoja vaidmenį, ir naudotojo žinutė, kurioje pateikiama sukomplektuota užklausa. Atkreipk dėmesį į temperature parametrą, čia nustatytą į 0,1. Kūrybiniame rašyme norisi įvairovės, o RAG atveju – priešingai. Nori, kad modelis kuo labiau laikytųsi to, kas pasakyta kontekste, ir kad du vykdymai su tuo pačiu klausimu duotų tą patį atsakymą. Aukšta temperatūra paskatintų modelį perfrazuoti, ekstrapoliuoti ir nukrypti nuo šaltinio.

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)

Veiksmo įkapsuliavimas klasėje

Išbarstytos funkcijos tinka tyrinėjimams, bet ne galutiniam pristatymui. Klasė RAGPipeline sujungia būseną – fragmentus, įterpčių (embeddings) matricą ir FAISS indeksą, sukurtą vieną kartą inicijavimo metu – bei tris operacijas: retrieve užkoduoja klausimą ir užklausia indeksą, generate surenka užklausą ir iškviečia modelį, o ask sujungia abu veiksmus. Atkreipk dėmesį, ką grąžina ask: ne eilutę, o žodyną, kuriame yra atsakymas, šaltinių sąrašas ir naudotų fragmentų skaičius. Šis atsekamumas ir skiria audituojamą asistentą nuo „juodosios dėžės“. Kai naudotojas suabejos atsakymu, tu žinosi, kuriais tekstais jis buvo pagrįstas.

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

Trys užklausų variantai pagal naudojimo atvejį

Galite specializuoti bazinę užklausą priklausomai nuo to, ko tikitės iš asistento. Jei naudotojai privalo patikrinti kiekvieną teiginį, aiškiai paprašykite citatų laužtiniuose skliaustuose. Tuomet modelis kiekvieną sakinį susies su sunumeruotu dokumentu. Jei atsakymas skirtas sąsajai ar ataskaitai, struktūruotas formatas užtikrina stabilias sekcijas: glaustas atsakymas, detalės, šaltiniai ir pasitikėjimo lygis, atspindintis, kaip gerai kontekstas apima klausimą. Trečiasis variantas atlieka kitokį vaidmenį: jis moko modelį išskaidyti neapibrėžtumą, atskiriant tai, ką galima teigti užtikrintai, ko trūksta ir kur ieškoti toliau. Praktikoje tai dažnai sukurpa naudingiausius asistentus, nes „man trūksta X“ yra geriau nei pasitikintis, bet klaidingas atsakymas.

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

Kalbant apie iškvietimo parametrus, RAG elgseną valdo trys nustatymai. Žema temperatūra užfiksuoja faktinį išvesties turinį, max_tokens neleidžia atsakymams virsti esė, o konservatyvus top_p apriboja imties žodyną tik tikėtiniausiais tęsiniais.

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

Svarbiausi punktai

  • RAG užklausa įterpia gautą kontekstą prieš klausimą
  • Naudokite žemą temperatūrą (0,1–0,3) faktiniams atsakymams
  • Paprašykite modelio cituoti šaltinius atsekamumui užtikrinti
  • Klasė RAGPipeline įkapsuliuoja visą eigą: išgavimas, generavimas, klausimas
  • Tvarkykite atvejus, kai kontekste trūksta pakankamai informacijos