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

Pilns RAG konveijers

Nodarbība 14 no 18 Atjaunota 2026. gada 2. novembris Programmētājs
Šajā lapā
  1. Viss kopā
  2. Pilns konveijers
  3. Konveijera palaišana
  4. Pieci virzieni turpmākiem uzlabojumiem
  5. Galvenās atziņas

Viss kopā

Iepriekšējās nodarbībās mēs aplūkojām katru ķēdes posmu atsevišķi: ielādi, sadalīšanu fragmentos, kodēšanu, indeksēšanu, izgūšanu un ģenerēšanu. Tagad ir laiks tos apvienot vienotā, pilnīgā, no sākuma līdz beigām strādājošā programmā, ko vari palaist tieši tādu, kāda tā ir, un pēc tam pielāgot saviem dokumentiem. Šis skripts ietilpst vienā failā un prasa tikai četras atkarības.

pip install mistralai faiss-cpu numpy requests

Pilns konveijers

Šo kodu strukturē divi dizaina lēmumi. Pirmkārt, visu konfigurāciju grupējam faila augšdaļā: modeļi, fragmenta izmērs, partijas lielums un TOP_K ir nosauktas konstantes. Tas pasargā tevi no vērtību meklēšanas funkciju dziļumos, kad nepieciešams pielāgot uzvedību. Otrkārt, loģiku sadalām sešās neatkarīgās funkcijās, katra atbilst vienam solim un izvada progresu kā [n/6]. Šī izsekošana nav tikai dekorācija: ja konveijers kļūst vai atgriež dīvainu atbildi, tā uzreiz norāda, vai problēma slēpjas ielādē, sadalīšanā fragmentos vai izgūšanā. Katru funkciju var arī aizstāt atsevišķi – piemēram, load_data vietā vari ievietot PDF ielādētāju, nepieskaroties pārējam kodam.

Funkcija main savieno soļus vienotā ķēdē, pēc tam uzdod trīs jautājumus par Pola Greiema eseju, ko izmantojam kā demonstrācijas datu kopu. Ņem vērā, ka izgūšana un ģenerēšana notiek ciklā, bet indeksēšana tiek veikta tikai vienreiz iepriekš: visas datu kopas pārkodēšana katram jautājumam būtu absurda gan izmaksu, gan latentuma ziņā.

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

# ============================================================
# Konfigurācija
# ============================================================
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. solis: Datu ielāde
# ============================================================
def load_data(url):
    """Ielādē teksta dokumentu no URL."""
    print("[1/6] Notiek datu ielāde...")
    response = requests.get(url)
    response.raise_for_status()
    text = response.text
    print(f"  -> Ielādētas {len(text)} rakstzīmes")
    return text


# ============================================================
# 2. solis: Fragmentu izveide
# ============================================================
def create_chunks(text, chunk_size=CHUNK_SIZE):
    """Sadalīt tekstu fragmentos."""
    print("[2/6] Notiek fragmentu izveide...")
    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"  -> Izveidoti {len(chunks)} fragmenti (vidējais izmērs: {sum(len(c) for c in chunks) // len(chunks)} rakstzīmes)")
    return chunks


# ============================================================
# 3. solis: Embedingu ģenerēšana
# ============================================================
def create_embeddings(chunks, batch_size=BATCH_SIZE):
    """Kodē fragmentus embedingos, izmantojot mistral-embed."""
    print("[3/6] Notiek embedingu ģenerēšana...")
    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"  -> Partija {i // batch_size + 1}/{(len(chunks) - 1) // batch_size + 1} nokodēta")

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


# ============================================================
# 4. solis: FAISS indeksa izveide
# ============================================================
def create_index(embeddings):
    """Izveido un aizpilda FAISS indeksu."""
    print("[4/6] Notiek FAISS indeksa izveide...")
    dimension = embeddings.shape[1]
    index = faiss.IndexFlatL2(dimension)
    index.add(embeddings)
    print(f"  -> Indekss: {index.ntotal} vektori, dimensija {dimension}")
    return index


# ============================================================
# 5. solis: Atbilstošo fragmentu izgūšana
# ============================================================
def retrieve(question, index, chunks, k=TOP_K):
    """Izgūst visatbilstošākos fragmentus."""
    print(f"[5/6] Meklēšana pēc: '{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"  -> Izgūti {len(results)} fragmenti")
    return results


# ============================================================
# 6. solis: Atbildes ģenerēšana
# ============================================================
def generate(question, context_chunks):
    """Ģenerē atbildi, izmantojot izgūto kontekstu."""
    print("[6/6] Notiek atbildes ģenerēšana...")

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

    prompt = f"""Informatīvs konteksts:

{context}

---

Pamatojoties TIKAI uz iepriekš minēto kontekstu, precīzi un pilnībā atbildi uz šo jautājumu.

Jautājums: {question}"""

    response = client.chat.complete(
        model=CHAT_MODEL,
        messages=[
            {"role": "system", "content": "Tu esi asistents, kas atbild, pamatojoties uz sniegto kontekstu."},
            {"role": "user", "content": prompt},
        ],
        temperature=0.1,
    )

    answer = response.choices[0].message.content
    print(f"  -> Atbilde ģenerēta ({len(answer)} rakstzīmes)")
    return answer


# ============================================================
# Galvenais konveijers
# ============================================================
def main():
    """Palaiž pilnu RAG konveijeru."""
    # 1. Ielāde
    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. Sadalīšana fragmentos
    chunks = create_chunks(text)

    # 3. Kodēšana
    embeddings = create_embeddings(chunks)

    # 4. Indeksēšana
    index = create_index(embeddings)

    # 5.+6. Jautājums -> Atbilde
    questions = [
        "What were the two main things the author worked on before college?",
        "What did the author do during their time at Y Combinator?",
        "What programming language did the author learn first?",
    ]

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


if __name__ == "__main__":
    main()

Konveijera palaišana

Saglabā šo kodu kā rag_pipeline.py, eksportē savu API atslēgu vidē – nekad neiekodē to failā, jo tas galu galā nonāks repozitorijā – un pēc tam palaid skriptu. Izvade izies cauri sešiem soļiem, pēc tam apstrādās trīs jautājumus ar to atbildēm. Ja kāda atbilde šķiet neatbilstoša tēmai, salīdzini to ar 5. solī parādītajiem fragmentiem, pirms vaino ģenerēšanas modeli.

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

Pieci virzieni turpmākiem uzlabojumiem

Šis konveijers ir pamats, nevis gatavs produkts, un katrs tā ierobežojums norāda uz nākamo soli. Vissvarīgākais ir noturība: pašreizējā formā skripts katrā palaišanas reizē pārkodē visu datu kopu, savukārt FAISS indeksa un fragmentu saglabāšana padarītu turpmākās izpildes gandrīz acumirklīgas. Nākamais līmenis ir pārkārtotā rangēšana (re-ranking), kas nodod FAISS rezultātus caur krustenisko kodētāju (cross-encoder), kas novērtē atbilstību daudz precīzāk nekā tikai vektoru attālums. Metadatu filtrēšana risina citu vajadzību: meklēšanas ierobežošana pēc datuma, kategorijas vai autora papildus līdzībai. Divi pēdējie uzlabojumi ir vērsti uz lietotāja pieredzi: straumēšana, kas parāda atbildi tās ģenerēšanas laikā, nevis pēc vairākām sekundēm klusuma, un sarunu vēsture, kas ļauj lietotājiem uzdot papildjautājumus, piemēram, „kā ir ar 2. versiju?”, nepārstāstot visu jautājumu no jauna.

# 1. Saglabā indeksu, lai izvairītos no pārrēķināšanas
faiss.write_index(index, "my_rag.index")
np.save("my_chunks.npy", np.array(chunks, dtype=object))

# 2. Pievieno pārkārtoto rangēšanu (re-ranking)
# Pēc FAISS izgūšanas izmanto krusteniskā kodētāja modeli,
# lai pārkārtotu rezultātus pēc smalkākas atbilstības

# 3. Metadatu filtrēšana
# Pievieno filtrus (datums, kategorija, autors) papildus
# vektoru līdzībai

# 4. Atbildes straumēšana
# Izmanto client.chat.stream(), lai parādītu atbildi
# tās ģenerēšanas laikā

# 5. Sarunu vēsture
# Pievieno iepriekšējās apmaiņas uzvednei,
# lai izveidotu kontekstuālu RAG čatbotu

Galvenās atziņas

  • Pilns RAG konveijers sadalās 6 soļos: ielāde, sadalīšana fragmentos, kodēšana, indeksēšana, izgūšana, ģenerēšana
  • Katrs solis ir neatkarīga funkcija, ko ir viegli testēt un aizstāt
  • Faktu balstītām atbildēm izmanto temperature=0.1
  • Saglabā FAISS indeksu un embedingus, lai izvairītos no to pārrēķināšanas katrā palaišanas reizē
  • Šis konveijers ir stabils sākumpunkts, ko bagātināt atbilstoši tavām vajadzībām