Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

Visiška RAG grandinė

Paskaita 14 iš 18 Atnaujinta 2026 m. lapkričio 2 d. Kūrėjas
Šiame puslapyje
  1. Viskas kartu
  2. Visiška grandinė
  3. Grandinės paleidimas
  4. Penkios kryptys tolesniam tobulinimui
  5. Svarbiausi punktai

Viskas kartu

Ankstesnėse pamokose nagrinėjome kiekvieną grandinės grandį atskirai: įkėlimą, skaidymą, kodavimą, indeksavimą, paiešką ir generavimą. Dabar metas jas sujungti į vieną visišką, nuo pradžios iki galo veikiančią programą, kurią gali paleisti iškart ir pritaikyti savo dokumentams. Šis scenarijus telpa į vieną failą ir reikalauja tik keturių priklausomybių.

pip install mistralai faiss-cpu numpy requests

Visiška grandinė

Šį kodą struktūrizuoja du projektavimo sprendimai. Pirma, visą konfigūraciją sugrupuojame failo viršuje: modeliai, gabalo dydis, paketo dydis ir TOP_K yra įvardytos konstantos. Tai sutaupo tau laiko ieškant užkoduotų reikšmių, paslėptų funkcijų viduje, kai reikia sureguliuoti elgseną. Antra, logiką padaliname į šešias nepriklausomas funkcijas, kurių kiekviena atitinka vieną žingsnį ir spausdina eigą kaip [n/6]. Šis pėdsakas nėra dekoratyvinis: kai grandinė sugenda arba grąžina keistą atsakymą, jis iškart parodo, ar problema kyla įkeliant, skaidant, ar vykdant paiešką. Kiekvieną funkciją taip pat galima pakeisti atskirai – pavyzdžiui, load_data gali pakeisti PDF įkėlėju neliesdamas likusios dalies.

Funkcija main sujungia žingsnius į grandinę, o tada užduoda tris klausimus apie Paulo Grahamo esė, naudotą kaip mūsų demonstracinę duomenų aibę. Atkreipk dėmesį, kad paieška ir generavimas vyksta cikle, o indeksavimas atliekamas tik vieną kartą iš anksto: viso korpuso perkodavimas kiekvienam klausimui būtų absurdiškas tiek kainos, tiek delsos požiūriu.

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

# ============================================================
# Konfigūracija
# ============================================================
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)


# ============================================================
# 1 žingsnis: Duomenų įkėlimas
# ============================================================
def load_data(url):
    """Įkelia tekstinį dokumentą iš URL."""
    print("[1/6] Įkeliami duomenys...")
    response = requests.get(url)
    response.raise_for_status()
    text = response.text
    print(f"  -> Įkelta {len(text)} simbolių")
    return text


# ============================================================
# 2 žingsnis: Gabalų kūrimas
# ============================================================
def create_chunks(text, chunk_size=CHUNK_SIZE):
    """Skaido tekstą į gabalus."""
    print("[2/6] Kuriami gabalai...")
    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"  -> Sukurta {len(chunks)} gabalų (vid. dydis: {sum(len(c) for c in chunks) // len(chunks)} simb.)")
    return chunks


# ============================================================
# 3 žingsnis: Įterpinių generavimas
# ============================================================
def create_embeddings(chunks, batch_size=BATCH_SIZE):
    """Koduoja gabalus į įterpinius naudojant mistral-embed."""
    print("[3/6] Generuojami įterpiniai...")
    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"  -> Paketas {i // batch_size + 1}/{(len(chunks) - 1) // batch_size + 1} užkoduotas")

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


# ============================================================
# 4 žingsnis: FAISS indekso kūrimas
# ============================================================
def create_index(embeddings):
    """Sukuria ir užpildo FAISS indeksą."""
    print("[4/6] Kuriamas FAISS indeksas...")
    dimension = embeddings.shape[1]
    index = faiss.IndexFlatL2(dimension)
    index.add(embeddings)
    print(f"  -> Indeksas: {index.ntotal} vektorių, dimensija {dimension}")
    return index


# ============================================================
# 5 žingsnis: Reikšmingų gabalų paieška
# ============================================================
def retrieve(question, index, chunks, k=TOP_K):
    """Randami reikšmingiausi gabalai."""
    print(f"[5/6] Ieškoma: '{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"  -> Rasta {len(results)} gabalų")
    return results


# ============================================================
# 6 žingsnis: Atsakymo generavimas
# ============================================================
def generate(question, context_chunks):
    """Generuoja atsakymą naudojant rastą kontekstą."""
    print("[6/6] Generuojamas atsakymas...")

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

    prompt = f"""Informatyvus kontekstas:

{context}

---

Remdamasis TIK aukščiau pateiktu kontekstu, tiksliai ir išsamiai atsakyk į šį klausimą.

Klausimas: {question}"""

    response = client.chat.complete(
        model=CHAT_MODEL,
        messages=[
            {"role": "system", "content": "Esi asistentas, atsakantis remiantis pateiktu kontekstu."},
            {"role": "user", "content": prompt},
        ],
        temperature=0.1,
    )

    answer = response.choices[0].message.content
    print(f"  -> Sugeneruotas atsakymas ({len(answer)} simbolių)")
    return answer


# ============================================================
# Pagrindinė grandinė
# ============================================================
def main():
    """Vykdo visą RAG grandinę."""
    # 1. Įkelti
    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. Skaidyti
    chunks = create_chunks(text)

    # 3. Koduoti
    embeddings = create_embeddings(chunks)

    # 4. Indeksuoti
    index = create_index(embeddings)

    # 5+6. Klausimas -> Atsakymas
    questions = [
        "Kokie buvo du pagrindiniai dalykai, kuriais autorius užsiėmė prieš stojant į koledžą?",
        "Ką autorius veikė dirbdamas Y Combinator?",
        "Kokią programavimo kalbą autorius išmoko pirmąją?",
    ]

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


if __name__ == "__main__":
    main()

Grandinės paleidimas

Išsaugok šį kodą kaip rag_pipeline.py, eksportuok savo API raktą aplinkos kintamuosiuose – niekada nekoduok jo tiesiai faile, nes jis galiausiai atsidurs saugykloje – ir paleisk scenarijų. Išvestis parodo visus šešis žingsnius, o tada apdoroja tris klausimus su jų atsakymais. Jei kuris nors atsakymas atrodo netinkamas, prieš kaltinant generavimo modelį, palygink jį su 5 žingsnyje rodomais gabalais.

export MISTRAL_API_KEY="tavo-api-raktas"
python rag_pipeline.py

Penkios kryptys tolesniam tobulinimui

Ši grandinė yra pamatas, o ne baigtas produktas, ir kiekvienas jos trūkumas rodo kitą žingsnį. Akivaizdžiausias yra išsaugojimas: dabartine forma scenarijus kiekvieno paleidimo metu iš naujo koduoja visą korpusą, tuo tarpu FAISS indekso ir gabalų išsaugojimas padarytų vėlesnius vykdymus beveik momentinius. Kitas lygmuo – perrikiavimas: FAISS rezultatus perduodant kryžminiam koduotojui (cross-encoder), kuris vertina reikšmingumą daug tiksliau nei vien vektoriaus atstumas. Metaduomenų filtravimas sprendžia kitą poreikį: paieškos apribojimas pagal datą, kategoriją ar autorių be panašumo. Du paskutiniai patobulinimai sutelkti į naudotojo patirtį: srautinis perdavimas (streaming), kai atsakymas rodomas generavimo metu, o ne po kelių sekundžių tylos, ir pokalbio istorija, leidžianti naudotojams klausti „o kaip dėl 2 versijos?“ nepateikiant viso klausimo iš naujo.

# 1. Išsaugoti indeksą, kad nereikėtų perskaičiuoti
faiss.write_index(index, "my_rag.index")
np.save("my_chunks.npy", np.array(chunks, dtype=object))

# 2. Pridėti perrikiavimą
# Po FAISS paieškos naudoti kryžminio koduotojo modelį
# rezultatams perrikiuoti pagal smulkų reikšmingumą

# 3. Metaduomenų filtravimas
# Pridėti filtrus (data, kategorija, autorius) be
# vektoriaus panašumo

# 4. Atsakymų srautinis perdavimas
# Naudoti client.chat.stream() atsakymui rodyti
# generavimo metu

# 5. Pokalbio istorija
# Pridėti ankstesnius mainus į užklausą
# kontekstiniam RAG pokalbių robotui

Svarbiausi punktai

  • Visiška RAG grandinė susideda iš 6 žingsnių: įkelti, skaidyti, koduoti, indeksuoti, ieškoti, generuoti
  • Kiekvienas žingsnis yra nepriklausoma funkcija, lengvai testuojama ir keičiama
  • Faktiniams atsakymams naudok temperature=0.1
  • Išsaugok FAISS indeksą ir įterpinius, kad išvengtum perskaičiavimo kiekvieno paleidimo metu
  • Ši grandinė yra tvirtas starto taškas, kurį gali praturtinti pagal savo poreikius