Léim go dtí an príomhábhar
Gaeilge— Roghnaigh teanga
Roghchlár

RAG Oiriúnaitheach

Ceacht 17 as 18 Nuashonraithe 2 Samhain 2026 Forbróir
Ar an leathanach seo
  1. Ceisteanna a chur ar an mbealach ceart go cliste
  2. An ródaire a chur i bhfeidhm
  3. An píblíne iomlán
  4. Príomhphointí

Ceisteanna a chur ar an mbealach ceart go cliste

Cuirfidh Self-RAG an cóireáil chéanna i bhfeidhm ar gach ceist, agus is é sin go díreach a laige. Fiafraigh de cad é dhá phlus dhá: déanfaidh sé an t-iasc a ionchódú, cuardóidh sé an t-innéacs, grádóidh sé ceithre dhoiciméad nach mbaineann leis an ábhar, aistreoidh sé go dtí an gréasán, ginfidh sé freagra, agus fíoróidh sé é. Sin dósan glaoch ar LLM le haghaidh ceiste a réitíonn an tsamhail láithreach. Níl an chastacht chéanna ag gach ceist, agus ní gá cóireáil chomh casta le haghaidh ceiste fhíricí simplí is mar a theastaíonn le haghaidh ceiste a éilíonn siontéis thar roinnt doiciméad. Dá bhrí sin, cuireann RAG Oiriúnaitheach ródaire cliste leis os comhair an phíblíne: déanann sé anailís ar an gceist agus roghnaíonn sé an straitéis is fearr sula dtosaíonn sé ar aon phróiseáil chostasach.

Tá trí cheann scríbe ag an ródaire. Téann ceisteanna faoi ábhair a chlúdaítear i ndáiríre i do dhoiciméid chuig an siopa veicteoir; is é seo an cosán RAG iomlán. Téann ceisteanna faoi imeachtaí reatha nó lasmuigh de raon an innéacsaithe chuig cuardach gréasáin, óir ní thabharfadh fiosrúchán ar an innéacs ach torann ar ais. Ar deireadh, faigheann ceisteanna simplí nó ceisteanna eolais ghinearálta freagra díreach ón tsamhail, gan aon aisghabháil ar chor ar bith.

An ródaire a chur i bhfeidhm

Is é an chuid dheacair ná go gcaithfidh an ródaire a bheith ar an eolas faoi raon do innéacs chun cinneadh a dhéanamh. Is é an réiteach a roghnaíodh chomh simplí agus atá sé éifeachtach: tabhair an liosta ábhar a chlúdaítear, indexed_topics, dó, agus déanfaidh sé comparáid idir é sin agus an cheist. Luaitear na trí riail go soiléir sa leid, agus ráthaíonn an formáid JSON srianta luach inúsáidte. Tá sé tábhachtach aird a thabhairt ar result.get("route", "vectorstore"): i gcás aschur gan choinne, fillfidh an luach réamhshocraithe ar an siopa veicteoir. Is é seo an iompar is sábháilte, ag brath ar do chuid sonraí seachas ar an ngréasán nó ar chuimhne na samhla.

import json
from mistralai.client import Mistral

client = Mistral(api_key=api_key)

def route_question(question, indexed_topics):
    """Route a question to the best strategy."""
    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")

# Test the 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}")

Léiríonn an tacar tástála gach cás agus beidh sé mar do shábháilteacht. Téann ceist faoi mistral-embed go díreach laistigh de na hábhair dhearbhaithe, mar sin téann sí chuig an siopa veicteoir. Athraíonn praghsanna stoc nó torthaí iomaíochta gach lá: ní féidir le haon innéacs statach iad a chur san áireamh, mar sin téann siad chuig an ngréasán. Ní gá corpas ná cuardach le haghaidh dhá phlus dhá. Úsáid an bloc seo arís le do chuid ábhar féin agus le cúig cheist déag thart a léiríonn do thrácht iarbhír: is é seo an bealach is eacnamaí chun a fhíorú go bhfuil an liosta topics cruinn go leor. Ní chuireann ródaire a sheolann gach rud chuig an siopa veicteoir aon luach leis, agus tá ródaire a fhreagraíonn go díreach ar do ábhair gnó guaiseach go hiomlán.

An píblíne iomlán

Tugann AdaptiveRAG le chéile gach rud a thóg tú sna trí cheacht dheireanacha. Tá modh feidhmithe dá chuid féin ag gach bealach, agus léitear an modh ask cosúil le ráiteas switch. Filleann an bealach direct láithreach, le teocht 0.3 ós rud é nach bhfuil aon chomhthéacs le cloí leis, agus liosta foinsí folamh a chuireann in iúl go hionraic don úsáideoir nach bhfuil aon rud ag tacú leis an bhfreagra seo. Gineann an bealach websearch ó thorthaí gréasáin amháin. Ach, leagann an bealach vectorstore an airtléire iomlán amach: grádú doiciméad i stíl Corrective RAG, cúltaca gréasáin mura maireann aon cheann acu, ansin lúb ghiniúna le seiceálacha bunaithe agus úsáideachta a thagann ó Self-RAG, arna ngrúpáil anseo in grade_and_correct.

Is fiú a thabhairt faoi deara difríocht tairsí amháin i gcomparáid leis an gceacht Corrective RAG. Níos spreagtar an cúltaca gréasáin a luaithe a chaitheann tú doiciméad amach, ach amháin má tá relevant_docs folamh. Tá an rogha seo níos fulangaí: nuair a fhanann dhá cheann as ceithre chunc ábhartha, tá sé réasúnach giniúint leo seachas dul chuig an ngréasán, rud a shábhálann glaoch agus a laghdaíonn moill. Caithfidh tú idirbheartú bunaithe ar riachtanais do fearainn.

import numpy as np

class AdaptiveRAG:
    """Adaptive RAG pipeline with intelligent routing."""

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

    def route(self, question):
        """Determine the optimal strategy."""
        return route_question(question, self.topics)

    def retrieve_from_vectorstore(self, question, k=4):
        """Retrieval from the local vector store."""
        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):
        """Web search for out-of-scope questions."""
        return web_search_fallback(question)

    def direct_answer(self, question):
        """Direct answer without retrieval."""
        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):
        """Generation with context (classic RAG)."""
        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):
        """Self-RAG checks (hallucinations + usefulness)."""
        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):
        """Complete Adaptive RAG pipeline."""
        print(f"\n{'='*60}")
        print(f"Question: {question}")

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

        # 2. Execute based on route
        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)

            # Document grading
            relevant_docs = []
            for doc in docs:
                if grade_document(question, doc["text"]):
                    relevant_docs.append(doc)

            # Web fallback if not enough relevant documents
            if not relevant_docs:
                print("  No relevant documents, web fallback...")
                relevant_docs = self.search_web(question)

            # Generation loop with verification
            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)

            # Return the last generation even if imperfect
            return {
                "answer": generation,
                "route": "vectorstore",
                "attempts": max_retries + 1,
                "sources": [d.get("source", "") for d in relevant_docs],
            }

# Usage
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]}...")

Siúlann na trí cheist shamplacha gach cosán in aon rith amháin, agus insíonn an réimse route sa toradh duit cé acu ceann a tógadh. Is é seo an luach ar chóir duit logáil i dtáirgeadh: is é dáileadh na mbealaí ar do thrácht iarbhír an táscaire sláinte is fearr do do chóras, ag nochtadh innéacs atá ró-chúng chomh maith le ródaire nach bhfuil calabrálaithe go maith.

Príomhphointí

  • Seolann RAG Oiriúnaitheach gach ceist chuig an straitéis is fearr (siopa veicteoir, gréasán, díreach)
  • Úsáideann an ródaire LLM le haschur struchtúrtha chun ceisteanna a aicmiú
  • Téann ceisteanna faoi ábhair innéacsaithe chuig an siopa veicteoir; téann an chuid eile chuig an ngréasán
  • Laghdaíonn an ródaire moill agus costais trí RAG iomlán a sheachaint le haghaidh ceisteanna simplí
  • Comhcheanglaíonn RAG Oiriúnaitheach smaointe ó Corrective RAG agus Self-RAG le ródaireacht