Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Teljes RAG folyamat

14. lecke 18 közül Frissítve 2026. november 2. Fejlesztő
Ezen az oldalon
  1. Az egész összerakása
  2. A teljes folyamat
  3. A folyamat futtatása
  4. Öt irány a további fejlesztéshez
  5. Főbb megállapítások

Az egész összerakása

Az előző leckék külön-külön tárgyalták a láncolat egyes elemeit: betöltés, darabolás, kódolás, indexelés, visszakeresés és generálás. Most itt az idő, hogy ezeket egyetlen, teljes, végponttól végpontig működő programmá hegeszd össze, amelyet azonnal futtathatsz, majd saját dokumentumaidhoz igazíthatsz. Ez a szkript egyetlen fájlba fér el, és mindössze négy függőséget igényel.

pip install mistralai faiss-cpu numpy requests

A teljes folyamat

Két tervezési döntés határozza meg ezt a kódot. Először is, a konfigurációt a fájl elején csoportosítjuk: a modellek, a darabok mérete, a köteg mérete és a TOP_K elnevezett állandók. Ez megkímél attól, hogy függvényekbe ágyazott, keményen kódolt értékeket kelljen keresgélned, amikor a viselkedést hangolnod kell. Másodszor, a logikát hat független függvényre bontjuk, amelyek mindegyike egy-egy lépésnek felel meg, és kiírja az előrehaladást [n/6] formátumban. Ez a naplózás nem díszítés: ha a folyamat meghibásodik vagy furcsa választ ad, azonnal megtudhatod, hogy a probléma a betöltésben, a darabolásban vagy a visszakeresésben rejlik-e. Minden függvény izoláltan is cserélhető – például beilleszthetsz egy PDF-betöltőt a load_data helyére anélkül, hogy a többi részt érintened kellene.

A main függvény láncolja össze a lépéseket, majd három kérdést tesz fel a Paul Graham esszéből álló demonstrációs adathalmazra. Figyeld meg, hogy a visszakeresés és a generálás a cikluson belül fut, míg az indexelés csak egyszer történik meg előtte: a teljes korpusz újrakódolása minden egyes kérdésre abszurd lenne mind költség, mind késleltetés szempontjából.

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

# ============================================================
# Konfiguráció
# ============================================================
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. lépés: Adatok betöltése
# ============================================================
def load_data(url):
    """Szöveges dokumentum betöltése URL-ről."""
    print("[1/6] Adatok betöltése...")
    response = requests.get(url)
    response.raise_for_status()
    text = response.text
    print(f"  -> {len(text)} karakter betöltve")
    return text


# ============================================================
# 2. lépés: Darabok létrehozása
# ============================================================
def create_chunks(text, chunk_size=CHUNK_SIZE):
    """Szöveg felosztása darabokra."""
    print("[2/6] Darabok létrehozása...")
    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"  -> {len(chunks)} darab létrehozva (átlagos méret: {sum(len(c) for c in chunks) // len(chunks)} karakter)")
    return chunks


# ============================================================
# 3. lépés: Beágyazások generálása
# ============================================================
def create_embeddings(chunks, batch_size=BATCH_SIZE):
    """Darabok kódolása beágyazásokká a mistral-embed segítségével."""
    print("[3/6] Beágyazások generálása...")
    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"  -> Köteg {i // batch_size + 1}/{(len(chunks) - 1) // batch_size + 1} kódolva")

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


# ============================================================
# 4. lépés: FAISS index létrehozása
# ============================================================
def create_index(embeddings):
    """FAISS index létrehozása és feltöltése."""
    print("[4/6] FAISS index létrehozása...")
    dimension = embeddings.shape[1]
    index = faiss.IndexFlatL2(dimension)
    index.add(embeddings)
    print(f"  -> Index: {index.ntotal} vektor, dimenzió: {dimension}")
    return index


# ============================================================
# 5. lépés: Releváns darabok visszakeresése
# ============================================================
def retrieve(question, index, chunks, k=TOP_K):
    """A legrelevánsabb darabok visszakeresése."""
    print(f"[5/6] Keresés erre: '{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"  -> {len(results)} darab visszakeresve")
    return results


# ============================================================
# 6. lépés: Válasz generálása
# ============================================================
def generate(question, context_chunks):
    """Válasz generálása a visszakeresett kontextus alapján."""
    print("[6/6] Válasz generálása...")

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

    prompt = f"""Informatív kontextus:

{context}

---

KIZÁRÓLAG a fenti kontextus alapján válaszolj pontosan és teljes körűen az alábbi kérdésre.

Kérdés: {question}"""

    response = client.chat.complete(
        model=CHAT_MODEL,
        messages=[
            {"role": "system", "content": "Olyan asszisztens vagy, aki a megadott kontextus alapján válaszol."},
            {"role": "user", "content": prompt},
        ],
        temperature=0.1,
    )

    answer = response.choices[0].message.content
    print(f"  -> Válasz generálva ({len(answer)} karakter)")
    return answer


# ============================================================
# Fő folyamat
# ============================================================
def main():
    """A teljes RAG folyamat futtatása."""
    # 1. Betöltés
    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. Darabolás
    chunks = create_chunks(text)

    # 3. Kódolás
    embeddings = create_embeddings(chunks)

    # 4. Indexelés
    index = create_index(embeddings)

    # 5+6. Kérdés -> Válasz
    questions = [
        "Mivel foglalkozott a szerző főként a főiskola előtt?",
        "Mit csinált a szerző a Y Combinatornál töltött ideje alatt?",
        "Melyik programozási nyelvet tanulta meg először a szerző?",
    ]

    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()

A folyamat futtatása

Mentsd el ezt a kódot rag_pipeline.py néven, állítsd be az API-kulcsodat a környezetben – soha ne kódold bele keményen a fájlba, mert az előbb-utóbb felkerül egy tárolóba –, majd futtasd a szkriptet. A kimenet végigvezet a hat lépésen, majd feldolgozza a három kérdést a válaszaikkal együtt. Ha valamelyik válasz témán kívülinek tűnik, hasonlítsd össze az 5. lépésben megjelenített darabokkal, mielőtt a generáló modellt hibáztatnád.

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

Öt irány a további fejlesztéshez

Ez a folyamat egy alap, nem pedig egy kész termék, és minden egyes korlátja egy következő lépésre mutat. A legkézenfekvőbb a tartósság: jelen formájában a szkript minden futtatáskor újrakódolja a teljes korpuszt, míg a FAISS index és a darabok elmentése szinte azonnaliá tenné a későbbi végrehajtásokat. A következő szint az újrarendezés (re-ranking), amikor a FAISS eredményeit egy kereszt-kódolón (cross-encoder) vezetjük át, amely a vektortávolságnál sokkal finomabban ítéli meg a relevanciát. A metaadat-szűrés egy másik igényt elégít ki: a hasonlóság mellett dátum, kategória vagy szerző szerinti keresés korlátozása. Két utolsó fejlesztés a felhasználói élményre fókuszál: az adatfolyam (streaming), amely generálás közben jeleníti meg a választ néhány másodpercnyi csend helyett, valamint a beszélgetési előzmények, amelyek lehetővé teszik a felhasználók számára, hogy olyan kérdésekkel folytassák, mint „mi a helyzet a 2-es verzióval?“, anélkül, hogy a teljes kérdést újra le kellene írniuk.

# 1. Az index elmentése az újraszámítás elkerülése érdekében
faiss.write_index(index, "my_rag.index")
np.save("my_chunks.npy", np.array(chunks, dtype=object))

# 2. Újrarendezés hozzáadása
# A FAISS visszakeresés után használj egy kereszt-kódoló modellt
# az eredmények finomabb relevancia szerinti sorba rendezésére

# 3. Metaadat-szűrés
# Szűrők hozzáadása (dátum, kategória, szerző)
# a vektorhasonlóság mellett

# 4. Válasz adatfolyam (streaming)
# Használd a client.chat.stream() függvényt a válasz
# generálás közbeni megjelenítéséhez

# 5. Beszélgetési előzmények
# Korábbi váltások hozzáadása a prompthoz
# egy kontextuális RAG chatbot érdekében

Főbb megállapítások

  • A teljes RAG folyamat 6 lépésre bontható: betöltés, darabolás, kódolás, indexelés, visszakeresés, generálás
  • Minden lépés egy független függvény, amelyet könnyű tesztelni és cserélni
  • Használj temperature=0.1 értéket a ténybeli válaszokhoz
  • Mentsd el a FAISS indexet és a beágyazásokat, hogy elkerüld az újraszámolást minden futtatáskor
  • Ez a folyamat szilárd kiindulópont, amelyet igényeid szerint gazdagíthatsz