Salt la conținutul principal
Română— Alege o limbă
Meniu

Arhitectura RAG completă

Lecția 11 din 22 Actualizată 3 noiembrie 2026 Dezvoltator
Pe această pagină
  1. Obiective
  2. Ce este RAG?
  3. Etapele Pipeline-ului
  4. Implementare Completă
  5. Utilizare
  6. Puncte de Optimizare
  7. Puncte cheie

Lecție actualizată la 3 noiembrie 2026 pe baza documentației OpenAI: parametrii temperature și top_p sunt acceptați doar cu un efort de raționament de none, în timp ce modelele GPT-5.6 raționează implicit (medium). Apelurile care setează acești parametri trebuie, prin urmare, să specifice reasoning={"effort": "none"} (Răspunsuri API) sau reasoning_effort="none" (Completări Chat). Surse: Utilizarea GPT-6 · GPT-5.6 Terra.

Obiective

  • Înțelegerea arhitecturii RAG de la capăt la capăt
  • Implementarea unui pipeline RAG funcțional
  • Identificarea componentelor de optimizat

Ce este RAG?

RAG (Retrieval-Augmented Generation – Generare Augmentată prin Recuperare) combină căutarea de documente cu generarea de text de către un LLM. În loc să se bazeze exclusiv pe cunoștințele sale interne, modelul primește documente relevante drept context, apoi își redactează răspunsul pe baza acelui context. Tot ce ați construit de la începutul acestui curs – embeddări, indexare, căutare, evaluare – devine aici prima jumătate a unui sistem complet.

De ce RAG?

Patru motive justifică această abordare, iar efectele lor se cumulează. În primul rând, datele proprietare: politica dumneavoastră de lucru la distanță, procedurile interne și catalogul de produse nu au apărut niciodată în datele de antrenament ale modelului, iar niciun prompt nu le va face să apară acolo. În al doilea rând, informațiile recente: orice este posterior datei de antrenament este invizibil pentru model, în timp ce un index se poate actualiza chiar în aceeași zi. Verificabilitatea contează tout autant, deoarece fiecare răspuns este ancorat în surse identificabile pe care utilizatorul le poate deschide și verifica – transformând natura încrederii acordate sistemului. În final, costul joacă în favoarea sa: adăugarea de cunoștințe prin RAG costă mult mai puțin decât fine-tuning-ul, iar corecțiile se fac prin ștergerea unui document, nu prin reantrenarea unui model.

Etapele Pipeline-ului

Citiți RAG în două faze distincte pe care nu trebuie să le confundați. Ingestia are loc offline, o singură dată sau ori de câte ori corpusul se actualizează:

Documente → Fragmentare (Chunking) → Embeddări → Stocare Vectorială

Interogarea are loc online, pentru fiecare întrebare pusă, și trebuie să rămână rapidă:

Întrebare → Embedding → Căutare → Context + Întrebare → LLM → Răspuns

Această separare are o consecință practică: costurile de ingestie se plătesc o singură dată și pot fi ridicate, în timp ce costurile de interogare se plătesc per apel și dictează experiența utilizatorului. Prin urmare, vă puteți permite o procesare sofisticată la ingestie, dar trebuie să rămâneți suplu la nivelul interogării.

Implementare Completă

Clasa următoare materializează cele trei faze în trei metode distincte, plus o a patra care le înlănțuie. Această separare nu este cosmetică: vă permite să testați căutarea fără a consuma tokeni de generare și să reluați generarea pe un context fix pentru a compara două prompturi.

from openai import OpenAI
import numpy as np

client = OpenAI()

class PipelineRAG:
    def __init__(
        self,
        model_embedding: str = "text-embedding-3-large",
        model_generation: str = "gpt-5.6-terra"
    ):
        self.client = OpenAI()
        self.model_embedding = model_embedding
        self.model_generation = model_generation
        self.chunks: list[dict] = []
        self.embeddings: np.ndarray | None = None

    # --- Faza de Ingestie ---

    def ingest(self, documents: list[dict]):
        """Ingestează documente {id, text, metadata}."""
        self.chunks = documents
        texts = [d["text"] for d in documents]

        # Generează embeddări în loturi
        all_emb = []
        for i in range(0, len(texts), 100):
            batch = texts[i:i + 100]
            resp = self.client.embeddings.create(
                input=batch, model=self.model_embedding
            )
            batch_emb = sorted(resp.data, key=lambda x: x.index)
            all_emb.extend([e.embedding for e in batch_emb])

        self.embeddings = np.array(all_emb, dtype=np.float32)
        print(f"Ingestie completă: {len(self.chunks)} fragmente indexate")

    # --- Faza de Recuperare ---

    def search(self, question: str, k: int = 5) -> list[dict]:
        """Găsește cele k fragmente mai relevante."""
        query_emb = self.client.embeddings.create(
            input=question, model=self.model_embedding
        ).data[0].embedding

        scores = self.embeddings @ np.array(query_emb)
        top_k = np.argsort(scores)[-k:][::-1]

        return [
            {**self.chunks[i], "score": float(scores[i])}
            for i in top_k
        ]

    # --- Faza de Generare ---

    def generate(self, question: str, contexts: list[dict]) -> str:
        """Generează un răspuns pe baza contextelor recuperate."""
        # Construiește promptul
        formatted_context = "\n\n---\n\n".join(
            f"[Sursă: {c.get('id', 'unknown')}]\n{c['text']}"
            for c in contexts
        )

        messages = [
            {
                "role": "system",
                "content": (
                    "Ești un asistent care răspunde la întrebări "
                    "bazându-se exclusiv pe documentele furnizate. "
                    "Dacă informația nu se află în documente, "
                    "menționează acest lucru clar. Citează-ți sursele."
                )
            },
            {
                "role": "user",
                "content": (
                    f"Documente de referință:\n\n{formatted_context}\n\n"
                    f"---\n\nÎntrebare: {question}"
                )
            }
        ]

        response = self.client.chat.completions.create(
            model=self.model_generation,
            reasoning_effort="none",  # temperature necesită effort none
            messages=messages,
            temperature=0.2
        )

        return response.choices[0].message.content

    # --- Pipeline Complet ---

    def answer(self, question: str, k: int = 5) -> dict:
        """Pipeline RAG complet: căutare → generare."""
        contexts = self.search(question, k=k)
        response = self.generate(question, contexts)

        return {
            "question": question,
            "response": response,
            "sources": [
                {"id": c["id"], "score": c["score"],
                 "excerpt": c["text"][:150]}
                for c in contexts
            ]
        }

Trei detalii din faza de generare determină majoritatea calității. Mesajul de sistem impune răspunsul exclusiv pe baza documentelor furnizate și admiterea lipsei de informații: fără această instrucțiune, modelul va completa golurile cu cunoștințele sale generale, oferind un răspuns plauzibil, dar inventat. Prefixul [Sursă: id] înaintea fiecărui extras oferă modelului ceva specific de citat, în loc de un vag „conform documentelor“. În final, o temperature de 0.2 reduce variabilitatea: pentru întrebări factuale pe o bază documentară, doriți consistență, nu creativitate.

Utilizare

Să testăm pipeline-ul pe un caz de afaceri minimal – trei politici interne și o întrebare care nu copiază niciuna dintre formulările lor exacte.

# Pregătește documentele
documents = [
    {
        "id": "leave-policy",
        "text": "Angajații beneficiază de 25 de zile de concediu plătit "
                 "pe an. Concediul trebuie solicitat cu cel puțin 2 săptămâni "
                 "în avans prin portalul HR.",
        "metadata": {"type": "hr", "date": "2026-01"}
    },
    {
        "id": "remote-work-policy",
        "text": "Lucrul la distanță este autorizat până la 3 zile pe săptămână. "
                 "Marțea și joia sunt zile obligatorii la birou. "
                 "Este necesar un acord scris cu managerul.",
        "metadata": {"type": "hr", "date": "2026-01"}
    },
    {
        "id": "reimbursement-procedure",
        "text": "Deconturile de cheltuieli trebuie depuse în termen de 30 de zile "
                 "de la efectuarea cheltuielii. Atașați chitanța originală. "
                 "Validarea de către supervisorul direct este necesară pentru sume peste 200 de euro.",
        "metadata": {"type": "finance", "date": "2026-01"}
    },
]

# Creează pipeline-ul
rag = PipelineRAG()
rag.ingest(documents)

# Pune o întrebare
result = rag.answer("Câte zile de lucru la distanță pe săptămână?")
print(result["response"])
print("\nSurse utilizate:")
for s in result["sources"]:
    print(f"  [{s['score']:.3f}] {s['id']}: {s['excerpt']}")

Împingeți exercițiul mai departe punând o întrebare la care niciun document nu răspunde, cum ar fi una despre planul de sănătate al companiei. Pipeline-ul va returna totuși trei surse – căutarea returnează întotdeauna cei mai buni k candidați ai săi – iar mesajul de sistem este cel care trebuie să împiedice modelul să inventeze un răspuns. Verificarea acestui comportament înainte de producție este preferabilă descoperirii lui printr-o plângere.

Puncte de Optimizare

Fiecare etapă a pipeline-ului poate fi îmbunătățită independent, permițând progrese prin ajustări mici și măsurabile.

EtapăOptimizări Posibile
Fragmentare (Chunking)Dimensiunea fragmentului, suprapunere, fragmentare semantică
EmbeddingAlegerea modelului, dimensiuni, îmbogățirea textului
CăutareHibridă, reranking, filtre pe metadate
PromptInstrucțiuni de sistem, formatul contextului, few-shot
GenerareModel, temperatură, citări

Lecțiile următoare detaliază fiecare dintre aceste optimizări. Abordați-le în această ordine: fragmentarea determină ceea ce poate fi recuperat, iar niciun reranking nu va repara un document fragmentat prost.

Puncte cheie

  • RAG = Căutare + Context + Generare LLM
  • Pipeline-ul se împarte în ingestie (offline) și interogare (online)
  • Fiecare componentă (fragmentare, embedding, căutare, prompt, generare) poate fi optimizată independent
  • RAG este mai flexibil și mai puțin costisitor decât fine-tuning-ul pentru adăugarea de cunoștințe