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

RAG Adattattiv

Lezzjoni 17 / 18 Aġġornat 2 ta’ Novembru 2026 Zviluppatur
F'din il-paġna
  1. Irrota l-mistoqsijiet b’mod intelliġenti
  2. Implimenta r-router
  3. Il-pipeline sħiħa
  4. Punti Ewlenin

Irrota l-mistoqsijiet b’mod intelliġenti

Is-Self-RAG japplika l-istess trattament għal kull mistoqsija, u dik eżattament hija n-nuqqas tiegħu. Jekk tistaqsih x’inhu żewġ pluss żewġ: se jikkodifika l-mistoqsija, ifittix fl-indiċi, jivvaluta erba’ dokumenti mhux rilevanti, jaqleb għall-web, jiġġenera u jivverifika. Dawn huma dożina ta’ sejħiet LLM għal mistoqsija li mudell isolvi istantanjament. Mhux il-mistoqsijiet kollha għandhom l-istess kumplessità, u mistoqsija fattwali sempliċi ma teħtiġx l-istess trattament bħal waħda li teħtieġ sinteżi minn dokumenti multipli. Għalhekk, ir-RAG Adattattiv iżid router intelliġenti qabel il-pipeline: janalizza l-mistoqsija u jagħżel l-istrateġija ottimali qabel ma jidħol f’ipproċessar għali.

Ir-router għandu tliet destinazzjonijiet. Il-mistoqsijiet dwar suġġetti koperti attwalment mid-dokumenti tiegħek imorru lejn il-maħżen vettorjali; din hija t-triq sħiħa tar-RAG. Il-mistoqsijiet dwar avvenimenti attwali jew barra mill-kamp indiċjat imorru lejn it-tiftix fil-web, peress li l-indiċi jirritorna biss storbju. Fl-aħħar nett, il-mistoqsijiet sempliċi jew ta’ għarfien ġenerali jirċievu tweġiba diretta mill-mudell, mingħajr l-ebda rkupru.

Implimenta r-router

Il-parti diffiċli hija li r-router irid ikun jaf il-kamp ta’ applikazzjoni tal-indiċi tiegħek biex jieħu deċiżjoni. Is-soluzzjoni magħżula hija sempliċi daqs kemm hija effettiva: tgħaddilu l-lista tas-suġġetti koperti, indexed_topics, li jqabbel mal-mistoqsija. It-tliet regoli huma ddikjarati b’mod espliċitu fil-prompt, u l-format JSON ristrett jiggarantixxi valur użabbli. Il-result.get("route", "vectorstore") jeħtieġ attenzjoni: f’każ ta’ output mhux mistenni, id-default jerġa’ lura għall-maħżen vettorjali. Dan huwa l-aktar imġiba sikura, li tiddependi fuq id-data tiegħek minflok il-web jew il-memorja tal-mudell.

import json
from mistralai.client import Mistral

client = Mistral(api_key=api_key)

def route_question(question, indexed_topics):
    """Irrota mistoqsija lejn l-aħjar strateġija."""
    topics_str = ", ".join(indexed_topics)

    prompt = f"""You are a question router. Given a question,
determine the best source of information.

Your indexed documents cover the following topics: {topics_str}

Rules:
- If the question concerns indexed topics -> "vectorstore"
- If the question concerns current events or an uncovered topic -> "websearch"
- If the question is very simple or general knowledge -> "direct"

Respond ONLY with a JSON object: {{"route": "vectorstore"}} or {{"route": "websearch"}} or {{"route": "direct"}}

Question: {question}

Route JSON:"""

    response = client.chat.complete(
        model="mistral-large-latest",
        messages=[{"role": "user", "content": prompt}],
        temperature=0,
        response_format={"type": "json_object"},
    )

    result = json.loads(response.choices[0].message.content)
    return result.get("route", "vectorstore")

# Ittestja r-router
topics = ["embeddings", "RAG", "Mistral AI", "vector search", "FAISS"]

tests = [
    "How does mistral-embed work?",          # -> vectorstore
    "What is Apple's stock price today?",  # -> websearch
    "How much is 2 + 2?",                        # -> direct
    "What are the steps of RAG?",             # -> vectorstore
    "Who won the 2026 World Cup?",         # -> websearch
]

for q in tests:
    route = route_question(q, topics)
    print(f"  [{route:12s}] {q}")

Is-sett tat-test juri kull xenarju u se jservi bħala s-sigurtà tiegħek. Mistoqsija dwar il-mistral-embed taqa’ eżattament fis-suġġetti ddikjarati, allura tmur lejn il-maħżen vettorjali. Il-prezzijiet tal-ishma jew ir-riżultati tal-kompetizzjonijiet jinbidu kuljum: l-ebda indiċi statiku ma jista’ jkun fihom, allura jmorru lejn il-web. Żewġ pluss żewġ ma jeħtiġix la korpus u lanqas tiftix. Uża mill-ġdid dan il-blokk bis-suġġetti tiegħek u madwar ħmistax-il mistoqsija rappreżentattiva tat-traffiku attwali tiegħek: din hija l-aktar mod ekonomiku biex tivverifika li l-lista topics hija preċiża biżżejjed. Router li jibgħat kollox lejn il-maħżen vettorjali ma jżid l-ebda valur, u router li jwieġeb direttament dwar is-suġġetti tan-negozju tiegħek huwa sempliċiment perikoluż.

Il-pipeline sħiħa

L-AdaptiveRAG jiġbor flimkien kull ma bnejt matul l-aħħar tliet lezzjonijiet. Kull rotta għandha l-metodu ta’ eżekuzzjoni tagħha, u l-metodu ask jinqara bħal dikjarazzjoni switch. Ir-rotta direct tirritorna immedjatament, b’temperatura ta’ 0.3 peress li m’hemm l-ebda kuntest li wieħed irid jaderixxi miegħu, u lista vojta ta’ sorsi li tissuġġerixxi onestament lill-utent li xejn ma jappoġġja din it-tweġiba. Ir-rotta websearch tiġġenera mir-riżultati tal-web biss. Ir-rotta vectorstore, madankollu, tiddispjega l-artillerija sħiħa: gradwazzjoni tad-dokumenti bl-istil ta’ Corrective RAG, fallback għall-web jekk l-ebda wieħed ma jibqa’, imbagħad ċiklu ta’ ġenerazzjoni b’verifiki ta’ fundamentazzjoni u utilità wirt mis-Self-RAG, raggruppati hawnhekk f’grade_and_correct.

Differenza waħda fil-limitu hija importanti meta mqabbla mal-lezzjoni dwar Corrective RAG. Il-fallback għall-web ma jiġix attivat malli jiġi skartat dokument, iżda biss jekk relevant_docs tkun vojta. Din il-għażla hija aktar tolleranti: meta żewġ minn erba’ biċċiet jibqgħu rilevanti, huwa raġonevoli li tiġġenera bihom minflok ma tmur għall-web, li tiffranka sejħa u tnaqqas il-latency. Trid tarbitra abbażi tar-rekwiżiti tad-dominju tiegħek.

import numpy as np

class AdaptiveRAG:
    """Pipeline RAG Adattattiv b'rotta intelliġenti."""

    def __init__(self, chunks, embeddings, index, topics):
        self.chunks = chunks
        self.embeddings = embeddings
        self.index = index
        self.topics = topics

    def route(self, question):
        """Iddetermina l-istrateġija ottimali."""
        return route_question(question, self.topics)

    def retrieve_from_vectorstore(self, question, k=4):
        """Irkupru mill-maħżen vettorjali lokali."""
        response = client.embeddings.create(
            model="mistral-embed", inputs=[question]
        )
        query_vec = np.array([response.data[0].embedding], dtype=np.float32)
        distances, indices = self.index.search(query_vec, k)

        return [
            {"text": self.chunks[idx]["text"], "source": "vectorstore"}
            for dist, idx in zip(distances[0], indices[0]) if idx >= 0
        ]

    def search_web(self, question):
        """Tiftix fil-web għal mistoqsijiet barra mill-kamp."""
        return web_search_fallback(question)

    def direct_answer(self, question):
        """Tweġiba diretta mingħajr irkupru."""
        response = client.chat.complete(
            model="mistral-large-latest",
            messages=[{"role": "user", "content": question}],
            temperature=0.3,
        )
        return response.choices[0].message.content

    def generate_with_context(self, question, documents):
        """Ġenerazzjoni bil-kuntest (RAG klassiku)."""
        context = "\n\n---\n\n".join([d["text"] for d in documents])
        prompt = f"Context:\n{context}\n\nQuestion: {question}"

        response = client.chat.complete(
            model="mistral-large-latest",
            messages=[
                {"role": "system", "content": "Answer based on the provided context."},
                {"role": "user", "content": prompt},
            ],
            temperature=0.1,
        )
        return response.choices[0].message.content

    def grade_and_correct(self, question, documents, generation):
        """Verifiki Self-RAG (alluċinazzjonijiet + utilità)."""
        is_grounded = check_hallucination(documents, generation)
        if not is_grounded:
            return None, "hallucination"

        is_useful = check_answer_usefulness(question, generation)
        if not is_useful:
            return None, "not_useful"

        return generation, "ok"

    def ask(self, question, max_retries=2):
        """Pipeline sħiħa ta' RAG Adattattiv."""
        print(f"\n{'='*60}")
        print(f"Question: {question}")

        # 1. Rotra
        route = self.route(question)
        print(f"Chosen route: {route}")

        # 2. Eżegwixxi abbażi tar-rotta
        if route == "direct":
            answer = self.direct_answer(question)
            return {"answer": answer, "route": "direct", "sources": []}

        elif route == "websearch":
            docs = self.search_web(question)
            answer = self.generate_with_context(question, docs)
            return {"answer": answer, "route": "websearch", "sources": ["web"]}

        else:  # vectorstore
            docs = self.retrieve_from_vectorstore(question)

            # Gradwazzjoni tad-dokumenti
            relevant_docs = []
            for doc in docs:
                if grade_document(question, doc["text"]):
                    relevant_docs.append(doc)

            # Fallback għall-web jekk m'hemmx biżżejjed dokumenti rilevanti
            if not relevant_docs:
                print("  No relevant documents, web fallback...")
                relevant_docs = self.search_web(question)

            # Ċiklu ta' ġenerazzjoni b'verifika
            for attempt in range(max_retries + 1):
                generation = self.generate_with_context(question, relevant_docs)
                answer, status = self.grade_and_correct(
                    question, relevant_docs, generation
                )

                if status == "ok":
                    return {
                        "answer": answer,
                        "route": "vectorstore",
                        "attempts": attempt + 1,
                        "sources": [d.get("source", "") for d in relevant_docs],
                    }
                elif status == "not_useful":
                    web_docs = self.search_web(question)
                    relevant_docs.extend(web_docs)

            # Irritorna l-aħħar ġenerazzjoni anke jekk mhix perfetta
            return {
                "answer": generation,
                "route": "vectorstore",
                "attempts": max_retries + 1,
                "sources": [d.get("source", "") for d in relevant_docs],
            }

# Użu
adaptive_rag = AdaptiveRAG(chunks, embeddings, index, topics=topics)

questions = [
    "How do I create a FAISS index with mistral-embed?",
    "What is the weather in Paris tomorrow?",
    "How many dimensions does codestral-embed have?",
]

for q in questions:
    result = adaptive_rag.ask(q)
    print(f"\nRoute: {result['route']}")
    print(f"Answer: {result['answer'][:200]}...")

It-tliet mistoqsijiet eżempju jgħaddu mit-toroq kollha f’daqqa waħda, u l-qasam route fir-riżultat jgħidlek liema waħda intużat. Dan huwa l-valur li għandek tirreġistra fil-produzzjoni: id-distribuzzjoni tar-rotot fit-traffiku reali tiegħek hija l-aħjar indikatur tas-saħħa tas-sistema tiegħek, li jikxef kemm indiċi dejjaq wisq kif ukoll router mal-kalibrat ħażin.

Punti Ewlenin

  • Ir-RAG Adattattiv jirrota kull mistoqsija lejn l-istrateġija ottimali (maħżen vettorjali, web, diretta)
  • Ir-router juża LLM b’output strutturat biex jikklassifika l-mistoqsijiet
  • Il-mistoqsijiet dwar suġġetti indiċjati jmorru lejn il-maħżen vettorjali; il-bqija jmorru lejn il-web
  • Ir-rotta tnaqqas il-latency u l-ispejjeż billi tevita RAG sħiħ għal mistoqsijiet sempliċi
  • Ir-RAG Adattattiv jgħaqqad ideat minn Corrective RAG u Self-RAG mar-rotta