Lähe põhisisu juurde
Eesti— Vali keel
Menüü

Terviklik RAG-i torustik

Õppetund 14 / 18 Värskendatud 2. november 2026 Arendajatele
Sellel lehel
  1. Kõige kokkupanemine
  2. Terviklik torustik
  3. Torustiku käivitamine
  4. Viis suunda edasiseks täiustamiseks
  5. Peamised punktid

Kõige kokkupanemine

Eelmistes tundides käsitlesime ahela iga lüli eraldi: laadimine, tükeldamine, kodeerimine, indekseerimine, päring ja genereerimine. Nüüd on aeg need üheks terviklikuks, otsast otsani toimivaks programmiks kokku keevitada, mida saad kohe käivitada ja seejärel oma dokumentidele kohandada. See skript mahub ühte faili ja nõuab vaid nelja sõltuvust.

pip install mistralai faiss-cpu numpy requests

Terviklik torustik

Seda koodi struktureerivad kaks disainivalikut. Esiteks koondame kogu konfiguratsiooni faili algusse: mudelid, tüki suurus, partii suurus ja TOP_K on nimetatud konstandid. See säästab sind vajadusest otsida funktsioonidesse peidetud kõvakodeeritud väärtusi, kui soovid käitumist häälestada. Teiseks jagame loogika kuueks sõltumatuks funktsiooniks, millest igaüks vastab ühele sammule ja prindib oma edenemist kujul [n/6]. See jälgimine pole dekoratiivne: kui torustik ebaõnnestub või tagastab veidra vastuse, annab see sulle kohe teada, kas probleem seisneb laadimises, tükeldamises või päringus. Iga funktsiooni saab ka isoleeritult asendada – saad vahetada load_data jaoks välja PDF-laadija, puutumata ülejäänud koodi.

Funktsioon main aheldab sammud kokku ja esitab seejärel korpusele kolm küsimust Paul Grahami essee kohta, mida kasutasime demoandmestikuna. Pane tähele, et päring ja genereerimine jooksevad tsükli sees, samas kui indekseerimine toimub vaid üks kord eelnevalt: kogu korpuse ümberkodeerimine iga küsimuse jaoks oleks nii kulude kui ka latentsuse seisukohalt absurdne.

import os
import json
import numpy as np
import faiss
import requests
from mistralai.client import Mistral

# ============================================================
# Konfiguratsioon
# ============================================================
MISTRAL_API_KEY = os.environ.get("MISTRAL_API_KEY")
EMBED_MODEL = "mistral-embed"
CHAT_MODEL = "mistral-large-latest"
CHUNK_SIZE = 2048
BATCH_SIZE = 25
TOP_K = 3

client = Mistral(api_key=MISTRAL_API_KEY)


# ============================================================
# Samm 1: Andmete laadimine
# ============================================================
def load_data(url):
    """Laadi tekstidokument URL-ilt."""
    print("[1/6] Andmete laadimine...")
    response = requests.get(url)
    response.raise_for_status()
    text = response.text
    print(f"  -> Laaditud {len(text)} tähemärki")
    return text


# ============================================================
# Samm 2: Tükkide loomine
# ============================================================
def create_chunks(text, chunk_size=CHUNK_SIZE):
    """Jaga tekst tükkideks."""
    print("[2/6] Tükkide loomine...")
    chunks = []
    paragraphs = text.split("\n\n")
    current = ""

    for para in paragraphs:
        para = para.strip()
        if not para:
            continue
        if len(current) + len(para) + 2 <= chunk_size:
            current = current + "\n\n" + para if current else para
        else:
            if current:
                chunks.append(current)
            current = para

    if current:
        chunks.append(current)

    print(f"  -> Loodud {len(chunks)} tükki (keskmine suurus: {sum(len(c) for c in chunks) // len(chunks)} tähemärki)")
    return chunks


# ============================================================
# Samm 3: Manuste genereerimine
# ============================================================
def create_embeddings(chunks, batch_size=BATCH_SIZE):
    """Kodeeri tükid manusteks kasutades mistral-embed."""
    print("[3/6] Manuste genereerimine...")
    all_embeddings = []

    for i in range(0, len(chunks), batch_size):
        batch = chunks[i:i + batch_size]
        response = client.embeddings.create(
            model=EMBED_MODEL,
            inputs=batch,
        )
        all_embeddings.extend([d.embedding for d in response.data])
        print(f"  -> Kodeeritud partii {i // batch_size + 1}/{(len(chunks) - 1) // batch_size + 1}")

    embeddings = np.array(all_embeddings, dtype=np.float32)
    print(f"  -> Maatriks: {embeddings.shape}")
    return embeddings


# ============================================================
# Samm 4: FAISS-i indeksi loomine
# ============================================================
def create_index(embeddings):
    """Loo ja täida FAISS-i indeks."""
    print("[4/6] FAISS-i indeksi loomine...")
    dimension = embeddings.shape[1]
    index = faiss.IndexFlatL2(dimension)
    index.add(embeddings)
    print(f"  -> Indeks: {index.ntotal} vektorit, mõõde {dimension}")
    return index


# ============================================================
# Samm 5: Asjakohaste tükkide päring
# ============================================================
def retrieve(question, index, chunks, k=TOP_K):
    """Päri kõige asjakohasemad tükid."""
    print(f"[5/6] Otsimine: '{question[:50]}...'")
    response = client.embeddings.create(
        model=EMBED_MODEL,
        inputs=[question],
    )
    query_vector = np.array([response.data[0].embedding], dtype=np.float32)

    distances, indices = index.search(query_vector, k)

    results = []
    for dist, idx in zip(distances[0], indices[0]):
        if idx >= 0:
            results.append({
                "text": chunks[idx],
                "distance": float(dist),
            })

    print(f"  -> Päritud {len(results)} tükki")
    return results


# ============================================================
# Samm 6: Vastuse genereerimine
# ============================================================
def generate(question, context_chunks):
    """Genereeri vastus kasutades päritud konteksti."""
    print("[6/6] Vastuse genereerimine...")

    context = "\n\n---\n\n".join([c["text"] for c in context_chunks])

    prompt = f"""Informatiivne kontekst:

{context}

---

Vasta järgmisele küsimusele täpselt ja põhjalikult, tuginedes AINULT ülaltoodud kontekstile.

Küsimus: {question}"""

    response = client.chat.complete(
        model=CHAT_MODEL,
        messages=[
            {"role": "system", "content": "Oled assistent, kes vastab pakutud konteksti põhjal."},
            {"role": "user", "content": prompt},
        ],
        temperature=0.1,
    )

    answer = response.choices[0].message.content
    print(f"  -> Vastus genereeritud ({len(answer)} tähemärki)")
    return answer


# ============================================================
# Peamine torustik
# ============================================================
def main():
    """Käivita terviklik RAG-i torustik."""
    # 1. Laadi
    url = "https://raw.githubusercontent.com/run-llama/llama_index/main/docs/docs/examples/data/paul_graham/paul_graham_essay.txt"
    text = load_data(url)

    # 2. Tükelda
    chunks = create_chunks(text)

    # 3. Kodeeri
    embeddings = create_embeddings(chunks)

    # 4. Indekseeri
    index = create_index(embeddings)

    # 5+6. Küsimus -> Vastus
    questions = [
        "Mis olid kaks peamist asja, millega autor tegeles enne ülikooli?",
        "Mida autor tegi oma aja jooksul Y Combinatoris?",
        "Millise programmeerimiskeele õppis autor esimesena?",
    ]

    for question in questions:
        print(f"\n{'='*60}")
        context = retrieve(question, index, chunks)
        answer = generate(question, context)
        print(f"\nK: {question}")
        print(f"V: {answer}")


if __name__ == "__main__":
    main()

Torustiku käivitamine

Salvesta see kood failina rag_pipeline.py, ekspordi oma API-võti keskkonnamuutujasse – ära kunagi kodeeri seda faili kõvasti, sest see satub lõpuks hoidlasse – ja käivita seejärel skript. Väljund viib sind läbi kuue sammu ja töötleb seejärel kolm küsimust koos vastustega. Kui mõni vastus tundub teemast väljas, võrdle seda 5. sammus kuvatavate tükkidega, enne kui süüdistad genereerimismudelit.

export MISTRAL_API_KEY="your-api-key"
python rag_pipeline.py

Viis suunda edasiseks täiustamiseks

See torustik on alus, mitte valmis toode, ja iga selle piirang osutab järgmisele sammule. Kõige ilmsem on püsivus: praegusel kujul kodeerib skript iga käivitamise korral kogu korpuse uuesti, samas kui FAISS-i indeksi ja tükkide salvestamine muudaks järgmised käivitused peaaegu hetkeliseks. Järgmine tase on ümberjärjestamine (re-ranking), kus FAISS-i tulemused lastakse läbi risti-kodeerija (cross-encoder), mis hindab asjakohasust palju peenemalt kui ainult vektori kaugus. Metaandmete filtreerimine lahendab teise vajaduse: otsingu piiramine kuupäeva, kategooria või autori järgi lisaks sarnasusele. Kaks viimast täiustust keskenduvad kasutajakogemusele: voogedastus (streaming), mis kuvab vastuse selle genereerimise käigus, mitte pärast mitmesekundilist vaikhust, ja vestluse ajalugu, mis võimaldab kasutajatel jätkata küsimusega „kuidas on lood versiooniga 2?“, ilma kogu küsimust uuesti sõnastamata.

# 1. Salvesta indeks, et vältida ümberarvutamist
faiss.write_index(index, "my_rag.index")
np.save("my_chunks.npy", np.array(chunks, dtype=object))

# 2. Lisa ümberjärjestamine
# Pärast FAISS-i päringut kasuta risti-kodeerija mudelit
# tulemuste ümberjärjestamiseks peenema asjakohasuse alusel

# 3. Metaandmete filtreerimine
# Lisa filtrid (kuupäev, kategooria, autor) lisaks
# vektorsarnasusele

# 4. Vastuse voogedastus
# Kasuta client.chat.stream(), et kuvada vastust
# selle genereerimise käigus

# 5. Vestluse ajalugu
# Lisa eelmised vahetused vihjesse
# kontekstipõhise RAG-i vestlusroboti jaoks

Peamised punktid

  • Terviklik RAG-i torustik jaguneb 6 sammuks: laadi, tükelda, kodeeri, indekseeri, päri, genereeri
  • Iga samm on sõltumatu funktsioon, mida on lihtne testida ja asendada
  • Kasuta faktiliste vastuste jaoks temperature=0.1
  • Salvesta FAISS-i indeks ja manused, et vältida iga käivituse korral ümberarvutamist
  • See torustik on kindel lähtepunkt, mida saad oma vajaduste põhjal rikastada