Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

Celoten cevovod RAG

Lekcija 14 od 18 Posodobljeno 2. november 2026 Razvijalec
Na tej strani
  1. Vse skupaj
  2. Celoten cevovod
  3. Zagon cevovoda
  4. Pet smeri za nadaljnje izboljšave
  5. Ključne ugotovitve

Vse skupaj

Prejšnje lekcije so obravnavale vsak člen v verigi posebej: nalaganje, razdeljevanje na dele, kodiranje, indeksiranje, pridobivanje in generiranje. Zdaj je čas, da jih združiš v en sam, popoln program od začetka do konca, ki ga lahko zaženeš takšno in ga nato prilagodiš svojim dokumentom. Ta skripta se prilega v eno datoteko in zahteva le štiri odvisnosti.

pip install mistralai faiss-cpu numpy requests

Celoten cevovod

Kodo strukturirata dve oblikovni odločitvi. Prvič, vso konfiguracijo združimo na vrhu datoteke: modeli, velikost dela, velikost serije in TOP_K so imenovane konstante. To ti prihrani iskanje trdo kodiranih vrednosti, skritih znotraj funkcij, ko moraš prilagoditi obnašanje. Drugič, logiko razdelimo na šest neodvisnih funkcij, od katerih vsaka ustreza enemu koraku in izpiše napredek kot [n/6]. Ta sled ni okrasna: ko cevovod odpove ali vrne čuden odgovor, ti takoj pove, ali je težava v nalaganju, razdeljevanju na dele ali pridobivanju. Vsako funkcijo lahko tudi izolirano zamenjaš – za load_data lahko vstaviš nalagalnik PDF brez dotikanja preostanka kode.

Funkcija main poveže korake skupaj, nato pa korpus poizveduje s tremi vprašanji o eseju Paula Grahama, ki smo ga uporabili kot demonstracijski nabor podatkov. Upoštevaj, da se pridobivanje in generiranje izvajata znotraj zanke, medtem ko se indeksiranje zgodi le enkrat vnaprej: ponovno kodiranje celotnega korpusa za vsako vprašanje bi bilo absurdno tako glede stroškov kot zakasnitve.

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

# ============================================================
# Konfiguracija
# ============================================================
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. korak: Nalaganje podatkov
# ============================================================
def load_data(url):
    """Naloži besedilni dokument z URL-ja."""
    print("[1/6] Nalaganje podatkov...")
    response = requests.get(url)
    response.raise_for_status()
    text = response.text
    print(f"  -> Naloženih {len(text)} znakov")
    return text


# ============================================================
# 2. korak: Ustvarjanje delov
# ============================================================
def create_chunks(text, chunk_size=CHUNK_SIZE):
    """Razdeli besedilo na dele."""
    print("[2/6] Ustvarjanje delov...")
    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"  -> Ustvarjenih {len(chunks)} delov (povprečna velikost: {sum(len(c) for c in chunks) // len(chunks)} znakov)")
    return chunks


# ============================================================
# 3. korak: Generiranje vdelav
# ============================================================
def create_embeddings(chunks, batch_size=BATCH_SIZE):
    """Kodiraj dele v vdelave prek mistral-embed."""
    print("[3/6] Generiranje vdelav...")
    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"  -> Serija {i // batch_size + 1}/{(len(chunks) - 1) // batch_size + 1} kodirana")

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


# ============================================================
# 4. korak: Ustvarjanje indeksa FAISS
# ============================================================
def create_index(embeddings):
    """Ustvari in napolni indeks FAISS."""
    print("[4/6] Ustvarjanje indeksa FAISS...")
    dimension = embeddings.shape[1]
    index = faiss.IndexFlatL2(dimension)
    index.add(embeddings)
    print(f"  -> Indeks: {index.ntotal} vektorjev, dimenzija {dimension}")
    return index


# ============================================================
# 5. korak: Pridobivanje ustreznih delov
# ============================================================
def retrieve(question, index, chunks, k=TOP_K):
    """Pridobi najbolj ustrezne dele."""
    print(f"[5/6] Iskanje za: '{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"  -> Pridobljenih {len(results)} delov")
    return results


# ============================================================
# 6. korak: Generiranje odgovora
# ============================================================
def generate(question, context_chunks):
    """Generiraj odgovor z uporabo pridobljenega konteksta."""
    print("[6/6] Generiranje odgovora...")

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

    prompt = f"""Informativni kontekst:

{context}

---

Glede SAMO na zgornji kontekst natančno in popolnoma odgovori na naslednje vprašanje.

Vprašanje: {question}"""

    response = client.chat.complete(
        model=CHAT_MODEL,
        messages=[
            {"role": "system", "content": "Si asistent, ki odgovarja na podlagi priloženega konteksta."},
            {"role": "user", "content": prompt},
        ],
        temperature=0.1,
    )

    answer = response.choices[0].message.content
    print(f"  -> Odgovor generiran ({len(answer)} znakov)")
    return answer


# ============================================================
# Glavni cevovod
# ============================================================
def main():
    """Zaženi celoten cevovod RAG."""
    # 1. Nalaganje
    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. Razdeljevanje na dele
    chunks = create_chunks(text)

    # 3. Kodiranje
    embeddings = create_embeddings(chunks)

    # 4. Indeksiranje
    index = create_index(embeddings)

    # 5+6. Vprašanje -> Odgovor
    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()

Zagon cevovoda

To kodo shrani kot rag_pipeline.py, izvozi svoj API ključ v okolje – nikoli ga ne kodiraj trdo v datoteko, saj bo ta sčasoma končala v repozitoriju – in nato zaženi skripto. Izhod te skozi šest korakov, nato pa obdela tri vprašanja z njihovimi odgovori. Če se kakšen odgovor zdi nepovezan, ga primerjaj z deli, prikazanimi v 5. koraku, preden obtožiš model za generiranje.

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

Pet smeri za nadaljnje izboljšave

Ta cevovod je temelj, ne končni izdelek, in vsaka od njegovih omejitev kaže na naslednji korak. Najbolj neposredna je trajnost: v trenutni obliki skripta vsakič znova kodira celoten korpus, medtem bi shranjevanje indeksa FAISS in delov naredilo naslednje izvedbe skoraj trenutne. Ponovno razvrščanje je naslednja raven, ki rezultate FAISS prenese skozi navzkrižni kodirnik (cross-encoder), ki presoja ustreznost veliko bolj natančno kot sama razdalja vektorjev. Filtriranje metapodatkov naslavlja drugo potrebo: omejevanje iskanja po datumu, kategoriji ali avtorju poleg podobnosti. Dve zadnji izboljšavi se osredotočata na uporabniško izkušnjo: pretakanje (streaming), ki prikazuje odgovor med generiranjem namesto po nekaj sekundah tišine, in zgodovina pogovora, ki uporabnikom omogoča nadaljevanje z vprašanjem „kaj pa različica 2?”, ne da bi morali ponoviti celotno vprašanje.

# 1. Shrani indeks, da se izogneš ponovnemu izračunu
faiss.write_index(index, "my_rag.index")
np.save("my_chunks.npy", np.array(chunks, dtype=object))

# 2. Dodaj ponovno razvrščanje
# Po pridobivanju FAISS uporabi model navzkrižnega kodirnika
# za ponovno razvrstitev rezultatov po podrobni ustreznosti

# 3. Filtriranje metapodatkov
# Dodaj filtre (datum, kategorija, avtor) poleg
# vektorske podobnosti

# 4. Pretakanje odgovora
# Uporabi client.chat.stream() za prikaz odgovora
# med generiranjem

# 5. Zgodovina pogovora
# Dodaj prejšnja izmenjave v poziv
# za kontekstualnega klepetalnega robota RAG

Ključne ugotovitve

  • Celoten cevovod RAG se razdeli na 6 korakov: nalaganje, razdeljevanje na dele, kodiranje, indeksiranje, pridobivanje, generiranje
  • Vsak korak je neodvisna funkcija, enostavna za testiranje in zamenjavo
  • Za dejanske odgovore uporabi temperature=0.1
  • Shrani indeks FAISS in vdelave, da se izogneš ponovnemu izračunu ob vsakem zagonu
  • Ta cevovod je trdna izhodiščna točka za bogatenje glede na tvoje potrebe