Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Retrieval un ģenerēšana

Nodarbība 13 no 18 Atjaunota 2026. gada 2. novembris Programmētājs
Šajā lapā
  1. No vektora uz atbildi
  2. RAG uzvednes veidošana
  3. Atbildes ģenerēšana
  4. Plūsmas encapsulēšana klasē
  5. Trīs uzvedņu varianti atkarībā no lietojuma gadījuma
  6. Galvenās atziņas

No vektora uz atbildi

Tu jau zini, kā indeksēt dokumentus un atlasīt tos, kas ir vistuvāk uzdotajam jautājumam. Atlicis tikai viens solis: pārvērst fragmentu sarakstu lasāmā atbildē. Tas nozīmē iegūtā konteksta ievadīšanu uzvednē (prompt), lai LLM formulētu atbildi, balstoties uz taviem datiem, nevis uz savu apmācības atmiņu. Tas prasa tikai dažas koda rindiņas, taču tas rada izšķirošu atšķirību kvalitātē. Labi noformēts konteksts un skaidra instrukcija ir tikpat svarīgi kā precīza atlase.

RAG uzvednes veidošana

Uzvednes struktūra ir vienkārša, taču katrai izvēlei ir sekas. Numerē fragmentus un norādi to avotu, lai modelis varētu precīzi citēt. Atdali tos ar redzamu atdalītāju ---, lai modelis neapvienotu divus pretrunīgus dokumentus vienā apgalvojumā. Vissvarīgākais: instrukcijai ir tieši jāierobežo atbilde tikai ar sniegto kontekstu un jāļauj modelim pateikt, ka tas nezina. Bez šīs atļaujas LLM, jautāts par trūkstošu informāciju, aizpildīs plaisu ar jebko, kas šķiet ticams. Tieši tāds ir halucināciju mehānisms.

def build_rag_prompt(question, retrieved_chunks):
    """Izveido RAG uzvedni ar iegūto kontekstu."""
    # Formatē kontekstu
    context_parts = []
    for i, chunk in enumerate(retrieved_chunks):
        source = chunk.get("source", "nezināms avots")
        context_parts.append(f"[Dokuments {i+1} - {source}]\n{chunk['text']}")

    context = "\n\n---\n\n".join(context_parts)

    prompt = f"""Tu esi eksperts asistents. Atbildi uz jautājumu, izmantojot
TIKAI zemāk sniegto kontekstu. Ja informācijas kontekstā nav,
to skaidri norādi.

## Konteksts

{context}

## Jautājums

{question}

## Atbilde"""

    return prompt

Atbildes ģenerēšana

Ģenerēšanas izsaukums ir vienkāršs: sistēmas ziņojums, kas atkārto lomu, un lietotāja ziņojums, kas satur sagatavoto uzvedni. Pievērs uzmanību temperatūras parametram, kas šeit iestatīts uz 0,1. Radošā rakstīšanā tev vajadzīga dažādība; RAG gadījumā – tieši pretēji. Tev ir jāpanāk, lai modelis pēc iespējas ciešāk pieturētos pie tā, kas teikts kontekstā, un lai divi izpildījumi ar vienu un to pašu jautājumu radītu vienu un to pašu atbildi. Augsta temperatūra mudinātu modeli pārrakstīt, ekstrapolēt un novirzīties no avota.

from mistralai.client import Mistral

client = Mistral(api_key=api_key)

def generate_answer(question, retrieved_chunks, model="mistral-large-latest"):
    """Ģenerē RAG atbildi, izmantojot Mistral."""
    prompt = build_rag_prompt(question, retrieved_chunks)

    response = client.chat.complete(
        model=model,
        messages=[
            {
                "role": "system",
                "content": "Tu esi precīzs asistents, kas atbild, balstoties uz sniegto kontekstu."
            },
            {
                "role": "user",
                "content": prompt,
            }
        ],
        temperature=0.1,  # Zema temperatūra faktisku atbilžu iegūšanai
    )

    return response.choices[0].message.content

# Piemērs
question = "Kādi ir galvenie RAG soļi?"
results = search_index(question, index, chunks, k=3)
answer = generate_answer(question, results)
print(answer)

Plūsmas encapsulēšana klasē

Izkaisītas funkcijas der izpētei, bet ne nodošanai ekspluatācijā. Klase RAGPipeline apvieno stāvokli – fragmentus, iegulšanu (embeddings) matricu un FAISS indeksu, kas tiek izveidots vienreiz inicializācijas brīdī – un trīs operācijas: retrieve kodē jautājumu un veic vaicājumu indeksā, generate saliek uzvedni un izsauc modeli, bet ask savieno abus šos soļus. Ņem vērā, ko atgriež ask: nevis virkni, bet gan vārdnīcu, kas satur atbildi, avotu sarakstu un izmantoto fragmentu skaitu. Tieši šī izsekojamība atšķir auditējamu asistentu no melnās kastes. Dienā, kad lietotājs apstrīdēs atbildi, tu zināsi, uz kuriem fragmentiem tā balstījās.

import numpy as np
import faiss
from mistralai.client import Mistral

client = Mistral(api_key=api_key)

class RAGPipeline:
    """Pilna RAG cauruļvada implementācija ar Mistral un FAISS."""

    def __init__(self, chunks, embeddings):
        self.chunks = chunks
        self.embeddings = embeddings.astype(np.float32)

        # Izveido FAISS indeksu
        dimension = embeddings.shape[1]
        self.index = faiss.IndexFlatL2(dimension)
        self.index.add(self.embeddings)

    def retrieve(self, question, k=3):
        """1. solis: atlasi atbilstošos fragmentus."""
        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):
        """2. solis: ģenerē atbildi ar kontekstu."""
        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):
        """Pilns cauruļvads: jautājums -> atbilde ar avotiem."""
        # Atlase
        context = self.retrieve(question, k=k)

        # Ģenerēšana
        answer = self.generate(question, context)

        return {
            "question": question,
            "answer": answer,
            "sources": [c["source"] for c in context],
            "n_chunks_used": len(context),
        }

# Lietošana
rag = RAGPipeline(chunks, embeddings)
result = rag.ask("Kā darbojas indeksēšana FAISS?")

print(f"Jautājums: {result['question']}")
print(f"Atbilde: {result['answer']}")
print(f"Avoti: {result['sources']}")

Trīs uzvedņu varianti atkarībā no lietojuma gadījuma

Tu vari specializēt bāzes uzvedni atkarībā no tā, ko sagaidi no asistenta. Ja lietotājiem ir jāpārbauda katrs apgalvojums, tieši pieprasi citātus iekavās. Tad modelis katram teikumam pievienos numurētu dokumentu. Ja atbilde tiek izmantota saskarnē vai ziņojumā, strukturēts formāts nodrošina stabilas sadaļas: kodolīga atbilde, detaļas, avoti un pārliecības līmenis, kas atspoguļo, cik labi konteksts sedz jautājumu. Trešais variants spēlē citu lomu: tas māca modelim sadalīt nenoteiktību, nošķirot to, ko tas var apgalvot, kas trūkst un kur meklēt tālāk. Praksē tas bieži rada visnoderīgākos asistentus, jo „man trūkst X” ir labāk nekā pārliecināta, bet nepareiza atbilde.

# 1. Uzvedne ar citēšanas instrukciju
prompt_cite = """Atbildi, citējot avota dokumentus iekavās.
Piemērs: "RAG uzlabo precizitāti [Dokuments 1]."

Konteksts: {context}
Jautājums: {question}"""

# 2. Uzvedne ar strukturētu formātu
prompt_structured = """Atbildi šādā formātā:

**Atbilde**: [tava kodolīgā atbilde]
**Detaļas**: [detalizēts skaidrojums]
**Avoti**: [izmantoto dokumentu saraksts]
**Pārliecība**: [augsta/vidēja/zema, balstoties uz konteksta pārklājumu]

Konteksts: {context}
Jautājums: {question}"""

# 3. Uzvedne ar trūkstošās informācijas apstrādi
prompt_honest = """Ja kontekstā nav pietiekami daudz informācijas,
lai pilnībā atbildētu, skaidri norādi:
- Ko vari apgalvot ar pārliecību
- Kas trūkst kontekstā
- Ieteikumus trūkstošās informācijas iegūšanai

Konteksts: {context}
Jautājums: {question}"""

Izsaukuma parametru ziņā trīs iestatījumi nosaka RAG uzvedību. Zema temperatūra fiksē faktisku izvadi, max_tokens novērš atbildes, kas pārvēršas esejas, bet konservatīvs top_p ierobežo izlases vārdu krājumu līdz visvarbūtīgākajiem turpinājumiem.

# RAG gadījumā izmanto zemu temperatūru
response = client.chat.complete(
    model="mistral-large-latest",
    messages=[{"role": "user", "content": prompt}],
    temperature=0.1,   # Faktisks, zema radošuma līmenis
    max_tokens=1024,    # Ierobežo atbildes garumu
    top_p=0.95,         # Konservatīva kodola izlase
)

Galvenās atziņas

  • RAG uzvednē iegūtais konteksts tiek ievadīts pirms jautājuma
  • Faktu balstītām atbildēm izmanto zemu temperatūru (0,1–0,3)
  • Pieprasi modelim citēt avotus izsekojamības nodrošināšanai
  • Klase RAGPipeline encapsulē visu plūsmu: atlase, ģenerēšana, jautāšana
  • Atrisini gadījumus, kad kontekstā trūkst pietiekamas informācijas