Aqbeż għall-kontenut ewlieni
Malti— Agħżel lingwa
Menu

Arkitettura RAG Sħiħa

Lezzjoni 11 / 22 Aġġornat 3 ta’ Novembru 2026 Zviluppatur
F'din il-paġna
  1. Għanijiet
  2. X’inhu r-RAG?
  3. Fażijiet tal-Pipeline
  4. Implimentazzjoni Sħiħa
  5. Użu
  6. Punti ta’ Ottimizzazzjoni
  7. Punti Ewlenin

Lezzjoni aġġornata fit-3 ta’ Novembru 2026 abbażi tad-dokumentazzjoni ta’ OpenAI: temperature u top_p huma aċċettati biss b’sforz ta’ raġunar ta’ none, filwaqt li l-mudelli GPT-5.6 jirraġunaw b’mod awtomatiku (medium). Għalhekk, is-sejħiet li jistabbilixxu dawn il-parametri għandhom jispeċifikaw reasoning={"effort": "none"} (API Responses) jew reasoning_effort="none" (Chat Completions). Sorsi: Using GPT-6 · GPT-5.6 Terra.

Għanijiet

  • Tifhem l-arkitettura RAG minn tarf għal ieħor
  • Timplimenta pipeline RAG funzjonali
  • Tidentifika l-komponenti li tista’ tottimizza

X’inhu r-RAG?

Ir-RAG (Retrieval-Augmented Generation) jgħaqqad it-tfittxija tad-dokumenti mal-ġenerazzjoni tat-test minn LLM. Minflok ma jiddependi biss fuq il-għarfien intern tiegħu, il-mudell jirċievi dokumenti rilevanti bħala kuntest, imbagħad ifassal it-tweġiba tiegħu abbażi ta’ dak il-kuntest. Kollox ma bnejt sa minn meta bdiet din il-kors—embeddings, indicizzazzjoni, tfittxija, evalwazzjoni—isir hawnhekk in-nofs ta’ quddiem ta’ sistema sħiħa.

Għaliex RAG?

Erba’ raġunijiet jiġġustifikawh, u dawn jikkumulaw. L-ewwel, data proprjetarja: il-politika tax-xogħol remot tiegħek, il-proċeduri interni u l-katalgu tal-prodotti qatt ma dehru fid-data ta’ taħriġ tal-mudell, u l-ebda prompt mhu se jġegħilha tidher hemm. It-tieni, informazzjoni riċenti: kull ħaġa wara d-data tat-taħriġ hija inviżibbli għall-mudell, filwaqt li indiċi jiġi aġġornat fl-istess jum. Il-verifikabbiltà hija importanti daqskemm, għax kull tweġiba tkun imwaħħla ma’ sorsi identifikabbli li l-utent jista’ jiftaħ u jiċċekkja—dan ibiddel in-natura tal-fiducja mogħtija lis-sistema. Fl-aħħar nett, l-ispiża taħdem favuru: iż-żieda tal-għarfien permezz ta’ RAG tispiċċa ferm inqas mill-fine-tuning, u l-korrezzjonijiet iseħħu billi tħassar dokument minflok ma terġa’ tħarreġ mudell.

Fażijiet tal-Pipeline

Aqra r-RAG f’żewġ fażijiet distinti li m’għandekx tħawwad. L-Inġestjoni (Ingestion) iseħħ offline, darba għal kollox jew kull meta jiġi aġġornat il-korpus:

Documents → Chunking → Embeddings → Vector Storage

Il-Mistoqsija (Query) iseħħ online, għal kull mistoqsija magħmula, u għandha tibqa’ mgħaġġla:

Question → Embedding → Search → Context + Question → LLM → Response

Din is-separazzjoni għandha konsegwenza prattika: l-ispejjeż tal-inġestjoni jitħallsu darba u jistgħu jkunu tqal, filwaqt li l-ispejjeż tal-mistoqsijiet jitħallsu għal kull sejħa u jiddettaw l-esperjenza tal-utent. Għalhekk, tista’ taffordja proċessar sofistikat tal-inġestjoni, iżda trid tibqa’ ħafif fuq in-naħa tal-mistoqsijiet.

Implimentazzjoni Sħiħa

Il-klassi li ġejja timmaterjalizza t-tliet fażijiet f’tliet metodi distinti, flimkien ma’ raba’ wieħed li jgħaqqadhom flimkien. Din is-separazzjoni mhix kożmetika: tippermettilek tittestja t-tfittxija mingħajr ma tikkonsma tokens tal-ġenerazzjoni, u terġa’ tgħaddi mill-ġenerazzjoni fuq kuntest fiss biex tqabbel żewġ prompts.

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

    # --- Ingestion Phase ---

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

        # Generate embeddings in batches
        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"Ingestion complete: {len(self.chunks)} chunks indexed")

    # --- Retrieval Phase ---

    def search(self, question: str, k: int = 5) -> list[dict]:
        """Finds the k most relevant chunks."""
        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
        ]

    # --- Generation Phase ---

    def generate(self, question: str, contexts: list[dict]) -> str:
        """Generates a response based on retrieved contexts."""
        # Build the prompt
        formatted_context = "\n\n---\n\n".join(
            f"[Source: {c.get('id', 'unknown')}]\n{c['text']}"
            for c in contexts
        )

        messages = [
            {
                "role": "system",
                "content": (
                    "You are an assistant that answers questions "
                    "based solely on the provided documents. "
                    "If the information is not in the documents, "
                    "state this clearly. Cite your sources."
                )
            },
            {
                "role": "user",
                "content": (
                    f"Reference documents:\n\n{formatted_context}\n\n"
                    f"---\n\nQuestion: {question}"
                )
            }
        ]

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

        return response.choices[0].message.content

    # --- Complete Pipeline ---

    def answer(self, question: str, k: int = 5) -> dict:
        """Complete RAG pipeline: search → generation."""
        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
            ]
        }

Tliet dettalji fil-fażi tal-ġenerazzjoni jmexxu l-biċċa l-kbira tal-kwalità. Il-messaġġ tas-sistema jobbliga li wieġeb biss mid-dokumenti pprovduti u li tammetti meta l-informazzjoni tkun nieqsa: mingħajr din l-istruzzjoni, il-mudell jimla l-lakuni bl-għarfien ġenerali tiegħu, u joħloq tweġiba plawżibbli iżda inventata. Il-prefiss [Source: id] qabel kull estratt jagħti lill-mudell xi ħaġa speċifika biex jikkwota, minflok “skont id-dokumenti” vaga. Fl-aħħar nett, temperature ta’ 0.2 inaqqas il-varjabbiltà: għal mistoqsijiet fattwali kontra bażi ta’ dokumenti, trid konsistenza, mhux kreattività.

Użu

Ejja nittestjaw il-pipeline fuq każ ta’ negozju minimu—tliet politiki interni, u mistoqsija li ma tikkopjax eżattament il-kliem tagħhom.

# Prepare documents
documents = [
    {
        "id": "leave-policy",
        "text": "Employees receive 25 days of paid leave "
                 "per year. Leave must be requested at least 2 weeks "
                 "in advance via the HR portal.",
        "metadata": {"type": "hr", "date": "2026-01"}
    },
    {
        "id": "remote-work-policy",
        "text": "Remote work is authorized up to 3 days per week. "
                 "Tuesdays and Thursdays are mandatory office days. "
                 "Written agreement with the manager is required.",
        "metadata": {"type": "hr", "date": "2026-01"}
    },
    {
        "id": "reimbursement-procedure",
        "text": "Expense reports must be submitted within 30 days "
                 "of the expense. Attach the original receipt. "
                 "Validation by the direct supervisor required for amounts over 200 euros.",
        "metadata": {"type": "finance", "date": "2026-01"}
    },
]

# Create the pipeline
rag = PipelineRAG()
rag.ingest(documents)

# Ask a question
result = rag.answer("How many days of remote work per week?")
print(result["response"])
print("\nSources used:")
for s in result["sources"]:
    print(f"  [{s['score']:.3f}] {s['id']}: {s['excerpt']}")

Imbotta l-eżerċizzju aktar ‘il quddiem billi tagħmel mistoqsija li l-ebda dokument ma jwieġeb, bħal waħda dwar il-pjan tas-saħħa tal-kumpanija. Il-pipeline xorta se tirritorna tliet sorsi—it-tfittxija dejjem tirritorna l-aqwa k kandidati tagħha—u huwa l-messaġġ tas-sistema li għandu jipprevjeni lill-mudell milli jinventa tweġiba. Li tivverifika dan l-imġiba qabel il-produzzjoni huwa aħjar milli tiskopriha permezz ta’ ilment.

Punti ta’ Ottimizzazzjoni

Kull pass tal-pipeline jista’ jittejjeb indipendentement, u jippermetti progress permezz ta’ titjibiet żgħar u kejjel.

PassOttimizzazzjonijiet Possibbli
ChunkingDaqs tal-biċċiet, overlap, chunking semantiku
EmbeddingGħażla tal-mudell, dimensjonijiet, arrikkiment tat-test
SearchIbridu, reranking, filtri tal-metadejta
PromptIstruzzjonijiet tas-sistema, format tal-kuntest, few-shot
GenerationMudell, temperatura, ċitazzjonijiet

Il-lezzjonijiet li ġejjin jiddettaljaw kull waħda minn dawn l-ottimizzazzjonijiet. Indirizzahom f’dan l-ordni: il-chunking jiddetermina x’jista’ jiġi rkuprat, u l-ebda reranking mhu se jissewwa dokument imqatta’ ħażin.

Punti Ewlenin

  • RAG = Tfittxija + Kuntest + Ġenerazzjoni LLM
  • Il-pipeline tinqasam f’inġestjoni (offline) u mistoqsija (online)
  • Kull komponent (chunking, embedding, tfittxija, prompt, ġenerazzjoni) jista’ jiġi ottimizzat indipendentement
  • Ir-RAG huwa aktar flessibbli u inqas għali mill-fine-tuning biex tiżdied għarfien