उन्नत आरएजी: लॉन्गआरएजी, सेल्फ-आरएजी और ग्राफआरएजी का वर्णन

Retrieval-Augmented Generation (RAG) ने बहुत सरल वेक्टर समानता खोज से परे विकास किया है। LongRAG, Self-RAG, और GraphRAG इन क्षमताओं के अग्रणी उदाहरण हैं।

आधुनिक RAG प्रणालियों को विशाल दस्तावेजों को संभालना, जटिल इकाई संबंधों को समझना और बहुत कुछ करने की आवश्यकता होती है।

यह सुंदर छवि AI मॉडल Flux 1 dev द्वारा उत्पन्न की गई है।

बुनियादी RAG से परे का विकास

परंपरागत RAG प्रणालियाँ एक सरल पैटर्न का पालन करती हैं: दस्तावेजों को टुकड़ों में बांटें, उन्हें वेक्टर में एम्बेड करें, कोसाइन समानता के माध्यम से समान टुकड़ों को प्राप्त करें, और उन्हें LLM को फीड करें। हालांकि कई उपयोग के मामलों के लिए प्रभावी, इस दृष्टिकोण को तीन महत्वपूर्ण स्थितियों में संघर्ष करना पड़ता है:

1. लंबी दूरी की निर्भरताएँ: महत्वपूर्ण संदर्भ कई टुकड़ों में हजारों टोकन तक फैला सकता है
2. प्राप्ति की विश्वास: प्रणाली को यह आकलन करने का कोई तरीका नहीं है कि प्राप्त सामग्री वास्तव में प्रासंगिक है
3. संबंध की जटिलता: वेक्टर समानता जटिल इकाइयों के बीच संबंधों को पकड़ नहीं सकती

उन्नत RAG वैरिएंट्स इन सीमाओं को विशेषीकृत आर्किटेक्चर के साथ संबोधित करते हैं जो विशिष्ट चुनौतियों के लिए बनाए गए हैं।

LongRAG: विस्तृत संदर्भ पर विजय

आर्किटेक्चर अवलोकन

LongRAG मूल रूप से चंकिंग रणनीति को पुनर्विचार करता है जिसमें विस्तृत संदर्भ विंडो (32K, 100K, या यहां तक कि 1M टोकन) वाले LLMs का उपयोग करता है। दस्तावेजों को छोटे 512-टोकन टुकड़ों में तोड़ने के बजाय, LongRAG एक हाइरार्किकल दृष्टिकोण का उपयोग करता है:

दस्तावेज-स्तर एम्बेडिंग: पूरे दस्तावेज (या बहुत बड़े खंड) को एक एकल इकाई के रूप में प्रोसेस किया जाता है। एक दस्तावेज-स्तर एम्बेडिंग समग्र अर्थग्राह्य अर्थ को पकड़ती है, जबकि डाउनस्ट्रीम प्रोसेसिंग के लिए पूर्ण पाठ को बनाए रखती है।

न्यूनतम विखंडन: जब चंकिंग आवश्यक होती है, तो LongRAG बहुत बड़े चंक (4K-8K टोकन) का उपयोग करता है जिसमें महत्वपूर्ण ओवरलैप (20-30%) होता है। यह कहानी के प्रवाह को बनाए रखता है और संदर्भ विखंडन को कम करता है।

संदर्भ संयोजन: प्राप्ति के समय, LongRAG बिखरे हुए टुकड़ों के बजाय पूरे दस्तावेजों या बड़े संरचित खंडों को वापस करता है। LLM को संरचनात्मक और अर्थग्राह्य संबंधों को बनाए रखने वाले निरंतर संदर्भ प्राप्त होते हैं।

कार्यान्वयन रणनीति

यहाँ Python और आधुनिक एम्बेडिंग मॉडल का उपयोग करके एक अवधारणात्मक कार्यान्वयन है:

from typing import List, Dict
import numpy as np

class LongRAGRetriever:
    def __init__(self, model, chunk_size=8000, overlap=1600):
        self.model = model
        self.chunk_size = chunk_size
        self.overlap = overlap
        self.doc_embeddings = []
        self.documents = []

    def create_long_chunks(self, text: str) -> List[str]:
        """ओवरलैपिंग बड़े चंक बनाएं"""
        chunks = []
        start = 0
        while start < len(text):
            end = start + self.chunk_size
            chunk = text[start:end]
            chunks.append(chunk)
            start += (self.chunk_size - self.overlap)
        return chunks

    def index_document(self, doc: str, metadata: Dict):
        """हाइरार्किकल एम्बेडिंग के साथ दस्तावेज इंडेक्स करें"""
        # पूरे दस्तावेज को एम्बेड करें
        doc_embedding = self.model.embed(doc)

        # ओवरलैप के साथ बड़े चंक बनाएं
        chunks = self.create_long_chunks(doc)
        chunk_embeddings = [self.model.embed(c) for c in chunks]

        self.doc_embeddings.append({
            'doc_id': len(self.documents),
            'doc_embedding': doc_embedding,
            'chunk_embeddings': chunk_embeddings,
            'chunks': chunks,
            'full_text': doc,
            'metadata': metadata
        })
        self.documents.append(doc)

    def retrieve(self, query: str, top_k: int = 3) -> List[Dict]:
        """प्रासंगिक लंबे रूप के सामग्री प्राप्त करें"""
        query_embedding = self.model.embed(query)

        # पहले दस्तावेज स्तर पर स्कोर करें
        doc_scores = [
            np.dot(query_embedding, doc['doc_embedding'])
            for doc in self.doc_embeddings
        ]

        # शीर्ष दस्तावेज प्राप्त करें
        top_doc_indices = np.argsort(doc_scores)[-top_k:][::-1]

        results = []
        for idx in top_doc_indices:
            doc_data = self.doc_embeddings[idx]

            # प्रत्येक दस्तावेज के लिए सबसे अच्छे चंक ढूंढें
            chunk_scores = [
                np.dot(query_embedding, emb)
                for emb in doc_data['chunk_embeddings']
            ]
            best_chunk_idx = np.argmax(chunk_scores)

            # सबसे अच्छे चंक के आसपास विस्तृत संदर्भ प्राप्त करें
            context_chunks = self._get_extended_context(
                doc_data['chunks'],
                best_chunk_idx
            )

            results.append({
                'text': ''.join(context_chunks),
                'score': doc_scores[idx],
                'metadata': doc_data['metadata']
            })

        return results

    def _get_extended_context(self, chunks: List[str],
                             center_idx: int) -> List[str]:
        """प्रासंगिक चंक के आसपास विस्तृत संदर्भ प्राप्त करें"""
        start = max(0, center_idx - 1)
        end = min(len(chunks), center_idx + 2)
        return chunks[start:end]

उपयोग के मामले और प्रदर्शन

LongRAG उन स्थितियों में उत्कृष्ट प्रदर्शन करता है जहां संदर्भ महत्वपूर्ण है:

• कानूनी दस्तावेज विश्लेषण: अनुबंध और कानूनी ब्रीफ अक्सर दर्जनों पृष्ठों तक फैले हुए निर्भरताओं होते हैं
• शोध पत्र प्राप्ति: विधि को समझने के लिए संरचित खंडों की आवश्यकता होती है, नहीं तो अलग-अलग अनुच्छेद
• कोड रिपॉजिटरी: फंक्शन और क्लास को अपने मॉड्यूल संदर्भ में समझना चाहिए

प्रदर्शन विशेषताएँ:

• लेटेंसी: बड़े चंक प्रोसेस करने के कारण अधिक (स्टैंडर्ड RAG से 2-5 गुना धीमा)
• सटीकता: लंबे रूप के QA बेंचमार्क पर 15-25% सुधार
• मेमोरी: संदर्भ विंडो के लिए 3-4 गुना अधिक मेमोरी की आवश्यकता

Self-RAG: स्व-चिंतन प्राप्ति

मूल सिद्धांत

Self-RAG RAG प्रणालियों में एक मेटा-कॉग्निटिव लेयर पेश करता है। प्राप्ति और उत्पादन के बजाय अंधेरे में, प्रणाली विशेष प्रतिबिंब टोकन के माध्यम से अपने स्वयं के प्रक्रियाओं पर सक्रिय रूप से चिंतन करती है:

प्राप्ति टोकन: यह निर्धारित करता है कि किसी दिए गए प्रश्न के लिए प्राप्ति की आवश्यकता है या नहीं प्रासंगिकता टोकन: यह आकलन करता है कि प्राप्त दस्तावेज वास्तव में प्रासंगिक हैं या नहीं सहायता टोकन: यह जांचता है कि उत्पन्न उत्तर प्राप्त सामग्री द्वारा समर्थित है या नहीं आलोचना टोकन: यह उत्पन्न प्रतिक्रिया की समग्र गुणवत्ता का आकलन करता है

आर्किटेक्चर घटक

Self-RAG आर्किटेक्चर तीन अंतर्विष्ट चरणों से बना है:

class SelfRAGSystem:
    def __init__(self, retriever, generator, critic):
        self.retriever = retriever
        self.generator = generator
        self.critic = critic

    def generate_with_reflection(self, query: str,
                                 max_iterations: int = 3):
        """स्व-प्रतिबिंब के साथ उत्तर उत्पन्न करें"""

        # चरण 1: निर्धारित करें कि प्राप्ति की आवश्यकता है या नहीं
        retrieve_decision = self.critic.should_retrieve(query)

        if not retrieve_decision:
            # प्राप्ति के बिना सीधा उत्पादन
            return self.generator.generate(query)

        # चरण 2: प्राप्ति और प्रासंगिकता का आकलन करें
        retrieved_docs = self.retriever.retrieve(query)
        relevant_docs = []

        for doc in retrieved_docs:
            relevance_score = self.critic.assess_relevance(
                query, doc
            )
            if relevance_score > 0.7:  # थ्रेशहोल्ड
                relevant_docs.append(doc)

        if not relevant_docs:
            # प्राप्ति के बिना उत्पादन पर वापस आना
            return self.generator.generate(query)

        # चरण 3: उत्पन्न और समर्थन की जांच करें
        best_answer = None
        best_score = -1

        for _ in range(max_iterations):
            # उम्मीदवार उत्तर उत्पन्न करें
            answer = self.generator.generate(
                query, context=relevant_docs
            )

            # समर्थन और गुणवत्ता का आकलन करें
            support_score = self.critic.check_support(
                answer, relevant_docs
            )
            quality_score = self.critic.assess_quality(answer)

            total_score = 0.6 * support_score + 0.4 * quality_score

            if total_score > best_score:
                best_score = total_score
                best_answer = answer

            # उच्च गुणवत्ता प्राप्त होने पर पूर्व समापन
            if total_score > 0.9:
                break

        return {
            'answer': best_answer,
            'confidence': best_score,
            'sources': relevant_docs,
            'reflections': {
                'retrieved': retrieve_decision,
                'relevance': len(relevant_docs),
                'support': support_score
            }
        }

प्रतिबिंब तंत्रों को प्रशिक्षित करना

Self-RAG को आलोचक घटक को विश्वसनीय आकलन करने के लिए प्रशिक्षित करने की आवश्यकता होती है। यह आमतौर पर शामिल करता है:

1. सुपरवाइज्ड फाइन-ट्यूनिंग उन डेटासेट पर जो प्रासंगिकता के निर्णयों के साथ एनोटेट किए गए हैं
2. रिनफोर्समेंट लर्निंग सटीक भविष्यवाणियों के लिए इनाम के साथ
3. कॉन्ट्रास्टिव लर्निंग समर्थित vs. असमर्थित दावों के बीच अंतर करने के लिए

प्रतिबिंब टोकन को निम्नलिखित के रूप में लागू किया जा सकता है:

• शब्दकोश में विशेष टोकन (जैसे [RETRIEVE], [RELEVANT])
• मॉडल पर अलग क्लासिफायर हेड
• बाहरी आलोचक मॉडल (एन्सेम्बल दृष्टिकोण)

उत्पादन विचार

Self-RAG को उत्पादन प्रणालियों में तैनात करने के दौरान:

लेटेंसी ट्रेड-ऑफ: प्रत्येक प्रतिबिंब चरण 20-40% इन्फरेंस ओवरहेड जोड़ता है। सावधानीपूर्वकता और प्रतिक्रिया समय आवश्यकताओं के बीच संतुलन बनाएं।

विश्वास थ्रेशहोल्ड: अपने उपयोग के मामले के आधार पर प्रतिबिंब थ्रेशहोल्ड को समायोजित करें। कानूनी या चिकित्सा अनुप्रयोगों को सामान्य चैटबॉट्स की तुलना में अधिक विश्वास की आवश्यकता होती है।

निगरानी: प्रतिबिंब निर्णयों को ट्रैक करें ताकि पैटर्न पहचाने जा सकें। यदि प्राप्ति कभी-कभार ही आवश्यक होती है, तो आप एक सरल आर्किटेक्चर से लाभान्वित हो सकते हैं।

ग्राफआरएजी: ज्ञान ग्राफ-एनहांस्ड रिट्रीवल

संकल्पनात्मक आधार

ग्राफआरएजी रिट्रीवल समस्या को वेक्टर समानता से ग्राफ ट्रैवर्सल में बदलता है। टेक्स्ट चंकों की खोज करने के बजाय, ग्राफआरएजी जुड़े हुए इकाइयों और संबंधों के संबंधित उप-ग्राफ पहचानता है।

इकाई निकालना: नामित इकाइयों, अवधारणाओं और उनके प्रकारों की पहचान करें संबंध मैपिंग: इकाइयों के बीच संबंधों को निकालें (समय, कारण, हायरार्की) ग्राफ निर्माण: इकाइयों को नोड्स और संबंधों को एजेस के रूप में ज्ञान ग्राफ बनाएं उप-ग्राफ रिट्रीवल: एक प्रश्न के लिए, संबंधित जुड़े हुए उप-ग्राफ ढूंढें

ग्राफ निर्माण पाइपलाइन

अनसंरचित टेक्स्ट से ज्ञान ग्राफ बनाने में कई चरण शामिल हैं:

class GraphRAGBuilder:
    def __init__(self, entity_extractor, relation_extractor):
        self.entity_extractor = entity_extractor
        self.relation_extractor = relation_extractor
        self.graph = NetworkGraph()

    def build_graph(self, documents: List[str]):
        """दस्तावेज़ों से ज्ञान ग्राफ बनाएं"""
        for doc in documents:
            # इकाइयों को निकालें
            entities = self.entity_extractor.extract(doc)

            # इकाइयों को नोड्स के रूप में जोड़ें
            for entity in entities:
                self.graph.add_node(
                    entity['text'],
                    entity_type=entity['type'],
                    context=entity['surrounding_text']
                )

            # संबंधों को निकालें
            relations = self.relation_extractor.extract(
                doc, entities
            )

            # संबंधों को एजेस के रूप में जोड़ें
            for rel in relations:
                self.graph.add_edge(
                    rel['source'],
                    rel['target'],
                    relation_type=rel['type'],
                    confidence=rel['score'],
                    evidence=rel['text_span']
                )

    def enrich_graph(self):
        """उत्पन्न संबंधों और मेटाडेटा जोड़ें"""
        # नोड महत्व की गणना करें (PageRank, आदि)
        self.graph.compute_centrality()

        # समुदाय/क्लस्टर पहचानें
        self.graph.detect_communities()

        # समय क्रम जोड़ें अगर टाइमस्टैम्प उपलब्ध हैं
        self.graph.add_temporal_edges()

ग्राफ्स के साथ प्रश्न प्रसंस्करण

ग्राफआरएजी प्रश्न ज्ञान ग्राफ के माध्यम से बहु-हॉप रीज़निंग शामिल करते हैं:

class GraphRAGRetriever:
    def __init__(self, graph, embedder):
        self.graph = graph
        self.embedder = embedder

    def retrieve_subgraph(self, query: str,
                         max_hops: int = 2,
                         max_nodes: int = 50):
        """प्रश्न के लिए संबंधित उप-ग्राफ प्राप्त करें"""

        # प्रश्न में सीड इकाइयों की पहचान करें
        query_entities = self.entity_extractor.extract(query)

        # ग्राफ में मिलान नोड्स ढूंढें
        seed_nodes = []
        for entity in query_entities:
            matches = self.graph.find_similar_nodes(
                entity['text'],
                similarity_threshold=0.85
            )
            seed_nodes.extend(matches)

        # ट्रैवर्सल के माध्यम से उप-ग्राफ का विस्तार करें
        subgraph = self.graph.create_subgraph()
        visited = set()

        for seed in seed_nodes:
            self._expand_from_node(
                seed,
                subgraph,
                visited,
                current_hop=0,
                max_hops=max_hops
            )

        # नोड्स को प्राथमिकता के अनुसार रैंक करें
        ranked_nodes = self._rank_subgraph_nodes(
            subgraph, query
        )

        # संदर्भ निकालें और प्रारूपित करें
        context = self._format_graph_context(
            ranked_nodes[:max_nodes],
            subgraph
        )

        return context

    def _expand_from_node(self, node, subgraph, visited,
                         current_hop, max_hops):
        """उप-ग्राफ को पुनरावर्ती रूप से विस्तार करें"""
        if current_hop >= max_hops or node in visited:
            return

        visited.add(node)
        subgraph.add_node(node)

        # पड़ोसी प्राप्त करें
        neighbors = self.graph.get_neighbors(node)

        for neighbor, edge_data in neighbors:
            # उप-ग्राफ में एज जोड़ें
            subgraph.add_edge(node, neighbor, edge_data)

            # पुनरावर्ती रूप से विस्तार करें
            self._expand_from_node(
                neighbor,
                subgraph,
                visited,
                current_hop + 1,
                max_hops
            )

    def _format_graph_context(self, nodes, subgraph):
        """उप-ग्राफ को पाठ संदर्भ में बदलें"""
        context_parts = []

        for node in nodes:
            # नोड संदर्भ जोड़ें
            context_parts.append(f"इकाई: {node.text}")
            context_parts.append(f"प्रकार: {node.entity_type}")

            # संबंध जानकारी जोड़ें
            edges = subgraph.get_edges(node)
            for edge in edges:
                context_parts.append(
                    f"- {edge.relation_type} -> {edge.target.text}"
                )

        return "\n".join(context_parts)

माइक्रोसॉफ्ट का ग्राफआरएजी कार्यान्वयन

माइक्रोसॉफ्ट का ग्राफआरएजी एक अनूठी विधि अपनाता है जिसमें समुदाय सारांशों का निर्माण शामिल है:

1. प्रारंभिक ग्राफ बनाएं दस्तावेजों का उपयोग करके LLM-आधारित इकाई/संबंध निकालने
2. समुदाय पहचानें लेडेन एल्गोरिदम या समान का उपयोग करके
3. सारांश बनाएं प्रत्येक समुदाय के लिए LLM का उपयोग करके
4. हायरार्किकल संरचना: कई स्तरों के समुदाय अभिव्यक्तियों का निर्माण करें
5. प्रश्न समय: संबंधित समुदायों को प्राप्त करें और विशिष्ट इकाइयों तक ट्रैवर्स करें

यह विधि विशेष रूप से प्रभावी है:

• अन्वेषणात्मक प्रश्न (“इस कॉर्पस में मुख्य विषय क्या हैं?”)
• बहु-हॉप रीज़निंग (“A को B के माध्यम से C से कैसे जोड़ा गया है?”)
• समय विश्लेषण (“इस इकाई के संबंधों का विकास कैसे हुआ?”)

तुलनात्मक विश्लेषण

प्रत्येक वैरिएंट का उपयोग कब करें

लॉन्गआरएजी का उपयोग करें जब:

• दस्तावेजों में मजबूत आंतरिक सहसंबंध हो
• आपकी LLM की कंटेक्स्ट विंडो बड़ी इनपुट्स (32K+) का समर्थन करें
• प्रश्न उत्तर में लंबी दूरी के निर्भरताओं की समझ की आवश्यकता हो
• आप संरचित दस्तावेजों (रिपोर्ट, पेपर, किताबें) के साथ काम कर रहे हैं

सेल्फ-आरएजी का उपयोग करें जब:

• सटीकता और विश्वसनीयता महत्वपूर्ण हो
• आप स्पष्ट रिट्रीवल निर्णयों की आवश्यकता है
• असंबंधित रिट्रीवल से गलत सकारात्मक महंगे हैं
• प्रश्न जटिलता में बहुत भिन्न होते हैं (कुछ को रिट्रीवल की आवश्यकता होती है, कुछ नहीं)

ग्राफआरएजी का उपयोग करें जब:

• आपकी डोमेन में समृद्ध इकाई संबंध हों
• प्रश्नों में बहु-हॉप रीज़निंग शामिल हो
• समय या हायरार्किकल संबंध महत्वपूर्ण हों
• आप इकाइयों के बीच कनेक्शन को समझने की आवश्यकता है

प्रदर्शन मेट्रिक्स तुलना

*ग्राफआरएजी सुधार डोमेन-निर्भर हैं

हाइब्रिड दृष्टिकोण

सबसे शक्तिशाली उत्पादन प्रणालियाँ अक्सर कई तकनीकों को मिलाकर बनती हैं:

लॉन्गआरएजी + ग्राफआरएजी: ग्राफ संरचना का उपयोग संबंधित दस्तावेज क्लस्टर पहचानने के लिए करें, फिर टुकड़ों के बजाय पूरे दस्तावेज प्राप्त करें

सेल्फ-आरएजी + ग्राफआरएजी: ग्राफ ट्रैवर्सल निर्णयों (कौन से पथों का अनुसरण करना है, विस्तार कब रोकना है) पर प्रतिबिंब तंत्र लागू करें

तीन-चरण पाइपलाइन: ग्राफआरएजी के लिए प्रारंभिक इकाई-आधारित रिट्रीवल → सेल्फ-आरएजी के लिए प्रासंगिकता फिल्टरिंग → लॉन्गआरएजी के लिए संदर्भ असेंबली

कार्यान्वयन विचार

एम्बेडिंग मॉडल्स

विभिन्न आरएजी वैरिएंट्स के लिए अलग-अलग एम्बेडिंग आवश्यकताएं होती हैं:

लॉन्गआरएजी: दस्तावेज-स्तर और चंकों-स्तर दोनों पर अच्छी तरह से काम करने वाले एम्बेडिंग्स की आवश्यकता होती है। लंबी अनुक्रमों पर कॉन्ट्रास्टिव लर्निंग से प्रशिक्षित मॉडल पर विचार करें।

सेल्फ-आरएजी: फाइन-ग्रेन्ड प्रासंगिकता आकलन के लिए सेमांटिक न्यूएंस को कैप्चर करने वाले एम्बेडिंग्स के लिए लाभकारी है।

ग्राफआरएजी: इकाई-सजग एम्बेडिंग्स की आवश्यकता होती है। इकाई लिंकिंग टास्क्स पर फाइन-ट्यून किए गए मॉडल बेहतर प्रदर्शन करते हैं।

एम्बेडिंग मॉडल का चयन प्रदर्शन पर महत्वपूर्ण प्रभाव डालता है। स्थानीय मॉडल्स के साथ काम करते समय, ओलामा जैसे उपकरणों से विभिन्न एम्बेडिंग मॉडल्स के साथ प्रयोग करने के लिए एक सरल तरीका प्रदान करते हैं, इससे पहले कि आप एक उत्पादन तैनाती के लिए प्रतिबद्ध हों।

चंकिंग रणनीतियाँ पुनः परिचय

परंपरागत फिक्स्ड-साइज चंकिंग उन्नत आरएजी के लिए अपर्याप्त है:

सेमांटिक चंकिंग: प्राकृतिक सीमाओं पर तोड़ें (अनुच्छेद, अनुभाग, विषय परिवर्तन) रिकर्सिव चंकिंग: माता-पिता-पुत्र संबंधों के साथ हायरार्किकल चंकों का निर्माण करें स्लाइडिंग विंडो: सीमाओं पर संदर्भ को संरक्षित करने के लिए ओवरलैपिंग चंकों का उपयोग करें स्ट्रक्चर-आवेयर: दस्तावेज संरचना का सम्मान करें (मार्कडाउन हेडर, XML टैग, कोड ब्लॉक्स)

पाइथन-आधारित कार्यान्वयनों के लिए, लैंगचेन और लामाइंडेक्स जैसे लाइब्रेरीज़ इन चंकिंग रणनीतियों के लिए बिल्ट-इन समर्थन प्रदान करते हैं।

रीरैंकिंग इंटीग्रेशन

रीरैंकिंग सभी आरएजी वैरिएंट्स में रिट्रीवल गुणवत्ता को महत्वपूर्ण रूप से सुधारता है। प्रारंभिक रिट्रीवल के बाद, एक विशेषीकृत रीरैंकिंग मॉडल क्वेरी-डॉक्यूमेंट इंटरैक्शन फीचर्स के आधार पर परिणामों को पुनः स्कोर करता है। यह विचारशील रूप से एकीकृत होने पर सटीकता में महत्वपूर्ण सुधार (10-20%) प्रदान करता है, जिसमें न्यूनतम लेटेंसी प्रभाव पड़ता है।

उत्पादन के लिए स्केलिंग

इंडेक्सिंग पाइपलाइन:

• बड़े दस्तावेज कॉर्पस के लिए वितरित प्रसंस्करण का उपयोग करें (रे, डास्क)
• रियल-टाइम अपडेट्स के लिए इन्क्रीमेंटल इंडेक्सिंग लागू करें
• ऑप्टिमाइज्ड वेक्टर डेटाबेस में एम्बेडिंग्स स्टोर करें (पाइनकोन, वेवियाट, क्वाड्रांट)

क्वेरी ऑप्टिमाइजेशन:

• अक्सर पूछे जाने वाले प्रश्नों और उनके परिणामों को कैश करें
• प्रश्न रूटिंग लागू करें (विभिन्न आरएजी वैरिएंट्स विभिन्न प्रश्न प्रकारों के लिए)
• उप-रैखिक स्केलिंग के लिए एप्रोक्सिमेट नियरस्ट नेइबर सर्च का उपयोग करें

मॉनिटरिंग:

• रिट्रीवल प्रासंगिकता स्कोर ट्रैक करें
• सेल्फ-आरएजी में प्रतिबिंब निर्णयों का मॉनिटरिंग करें
• ग्राफ ट्रैवर्सल पथों और गहराई को मापें
• कॉन्फिडेंस स्कोर और यूजर फीडबैक लॉग करें

वास्तविक दुनिया के अनुप्रयोग

तकनीकी दस्तावेज़ीकरण सर्च

एक प्रमुख क्लाउड प्रदाता ने अपने दस्तावेज़ीकरण के लिए ग्राफआरएजी लागू किया:

• इकाइयाँ: API एंडपॉइंट्स, पैरामीटर्स, एरर कोड्स, सेवा नाम
• संबंध: निर्भरताएँ, संस्करण संगतता, माइग्रेशन पथ
• परिणाम: समर्थन टिकटों में 35% की कमी, 45% तेज़ समाधान समय

कानूनी डिस्कवरी

एक कानूनी टेक कंपनी ने सेल्फ-आरएजी को लॉन्गआरएजी के साथ मिलाया:

• सेल्फ-आरएजी असंबंधित दस्तावेजों को प्रारंभिक रूप से फिल्टर करता है
• लॉन्गआरएजी रिटेन किए गए दस्तावेजों में संदर्भ को संरक्षित करता है
• वकीलों को 60% कम गलत सकारात्मक समीक्षा करने की आवश्यकता है
• महत्वपूर्ण संदर्भ संरक्षण 71% से बढ़कर 94% हो गया

शोध साहित्य समीक्षा

हाइब्रिड दृष्टिकोण का उपयोग करने वाला अकादमिक सर्च इंजन:

• ग्राफआरएजी सिटेशन नेटवर्क और शोध समुदाय पहचानता है
• लॉन्गआरएजी पूर्ण अनुभागों को प्राप्त करता है जिसमें विधि संदर्भ संरक्षित है
• 40% सुधार संबंधित पेपर खोज में
• साहित्य समीक्षा के समय को हफ्तों से दिनों में कम किया गया

उन्नत विषय

मल्टी-मोडल RAG

इमेजेज, टेबल्स, और कोड को हैंडल करने के लिए इन वैरिएंट्स को बढ़ाना:

• विज़ुअल ग्राउंडिंग: दस्तावेज़ों में इमेजेज से टेक्स्ट एंटिटीज़ को लिंक करना
• टेबल अंडरस्टैंडिंग: संरचित डेटा को ग्राफ़ फॉर्मेट में पार्स करना
• कोड एनालिसिस: कोडबेस से डिपेंडेंसी ग्राफ़ बनाना

एडाप्टिव RAG

क्वेरी विशेषताओं के आधार पर RAG रणनीति का डायनामिक चयन:

• क्वेरी जटिलता क्लासिफायर
• दस्तावेज़ प्रकार डिटेक्टर
• रणनीति चयन के लिए कॉस्ट-बेनेफिट ऑप्टिमाइज़र

प्राइवेसी-प्रिज़र्विंग RAG

प्राइवेसी प्रतिबंधों के साथ इन वैरिएंट्स को लागू करना:

• डेटा सिलोज़ के बीच फेडरेटेड रिट्रीवल
• एम्बेडिंग्स में डिफरेंशियल प्राइवेसी
• एन्क्रिप्टेड सिमिलारिटी सर्च

शुरू करने के लिए

पाइथन के साथ क्विक स्टार्ट

इन तकनीकों को लागू करने के लिए, एक मजबूत पाइथन फाउंडेशन के साथ शुरू करना आवश्यक है। मशीन लर्निंग के लिए पाइथन की समृद्ध पारिस्थितिकी इसे RAG विकास के लिए प्राकृतिक चयन बनाती है।

प्रयोग के लिए एक सरल शुरुआती बिंदु:

# डिपेंडेंसीज़ इंस्टॉल करें
# pip install sentence-transformers faiss-cpu langchain

from sentence_transformers import SentenceTransformer
import faiss
import numpy as np

# लंबे चंक के साथ प्रयोग करने के लिए बुनियादी सेटअप
model = SentenceTransformer('all-MiniLM-L6-v2')

documents = [
    # यहाँ आपके लंबे-फॉर्म दस्तावेज़
]

# एम्बेडिंग्स बनाएं
embeddings = model.encode(documents)

# FAISS इंडेक्स बनाएं
dimension = embeddings.shape[1]
index = faiss.IndexFlatL2(dimension)
index.add(embeddings.astype('float32'))

# क्वेरी
query = "आपका प्रश्न यहाँ"
query_embedding = model.encode([query])
distances, indices = index.search(
    query_embedding.astype('float32'), k=3
)

फ्रेमवर्क चयन

LangChain: रैपिड प्रोटोटाइपिंग के लिए सर्वोत्तम, विस्तृत इंटीग्रेशन LlamaIndex: दस्तावेज़ इंडेक्सिंग और रिट्रीवल के लिए अनुकूलित Haystack: प्रोडक्शन-रेडी, मजबूत पाइपलाइन एब्स्ट्रैक्शंस कस्टम: जब आपको पूर्ण नियंत्रण और अनुकूलन की आवश्यकता हो

मूल्यांकन फ्रेमवर्क

प्रोडक्शन डिप्लॉयमेंट से पहले कड़ी मूल्यांकन लागू करें:

रिट्रीवल मेट्रिक्स:

• प्रिसिजन@K, रिकॉल@K, MRR (मीन रेसिप्रोकल रैंक)
• NDCG (नॉर्मलाइज़्ड डिस्काउंटेड क्यूमुलेटिव गेन)

जेनरेशन मेट्रिक्स:

• टेक्स्ट समानता के लिए ROUGE, BLEU
• सेमांटिक समानता के लिए BERTScore
• गुणवत्ता आकलन के लिए मानव मूल्यांकन

एंड-टू-एंड मेट्रिक्स:

• टास्क सफलता दर
• उपयोगकर्ता संतुष्टि स्कोर
• लेटेंसी पर्सेंटाइल्स (p50, p95, p99)

निष्कर्ष

RAG सिस्टम की लैंडस्केप बेसिक वेक्टर सिमिलारिटी सर्च से काफी आगे बढ़ चुकी है। LongRAG, Self-RAG, और GraphRAG पारंपरिक दृष्टिकोणों की विशिष्ट सीमाओं को संबोधित करते हैं:

LongRAG कंटेक्स्ट फ्रैगमेंटेशन समस्या को बड़े कंटेक्स्ट विंडोज और न्यूनतम चंकिंग को अपनाकर हल करता है। यह उस समय सर्वोत्तम विकल्प है जब दस्तावेज़ सहसंबंध महत्वपूर्ण है और आपके पास बड़े कंटेक्स्ट्स को हैंडल करने के लिए कंप्यूटेशनल संसाधन हैं।

Self-RAG रिट्रीवल सिस्टम में महत्वपूर्ण स्व-चेतना जोड़ता है। अपने ही निर्णयों पर विचार करके, यह फाल्स पॉजिटिव्स को कम करता है और विश्वसनीयता बढ़ाता है—उच्च-स्टेक्स एप्लिकेशंस के लिए आवश्यक है जहां सटीकता की तुलना में गति अधिक महत्वपूर्ण है।

GraphRAG संरचित ज्ञान प्रतिनिधित्व की शक्ति को खोलता है। जब आपका डोमेन एंटिटीज़ के बीच जटिल संबंधों से संबंधित है, तो ग्राफ़-आधारित रिट्रीवल वे कनेक्शन सर्फेस कर सकता है जिन्हें वेक्टर सिमिलारिटी पूरी तरह से मिस कर देता है।

RAG का भविष्य संभवतः इन वैरिएंट्स की ताकतों को मिलाने वाले हाइब्रिड दृष्टिकोणों को शामिल करता है। एक प्रोडक्शन सिस्टम GraphRAG का उपयोग संबंधित एंटिटी क्लस्टर पहचानने के लिए कर सकता है, Self-RAG रिट्रीवल्स को फ़िल्टर और वैलिडेट करने के लिए, और LongRAG को LLM के लिए सहज कंटेक्स्ट असेंबल करने के लिए।

जैसे-जैसे LLMs बेहतर होते हैं और कंटेक्स्ट विंडोज बढ़ते हैं, हम और भी अधिक जटिल RAG वैरिएंट्स देखेंगे। महत्वपूर्ण बात यह है कि अपने विशिष्ट उपयोग मामले की आवश्यकताओं—दस्तावेज़ संरचना, क्वेरी पैटर्न, सटीकता मांग, और कंप्यूटेशनल प्रतिबंधों—को समझना और उपयुक्त तकनीक या उनके संयोजन का चयन करना है।

टूलिंग पारिस्थितिकी तेजी से परिपक्व हो रही है, जिसमें LangChain, LlamaIndex, और Haystack इन उन्नत पैटर्न के लिए increasingly sophisticated support प्रदान कर रहे हैं। शक्तिशाली लोकल LLM रनटाइम और एम्बेडिंग मॉडल्स के साथ, अब कभी भी प्रोडक्शन-ग्रेड RAG सिस्टम्स के साथ प्रयोग करना और उन्हें डिप्लॉय करना आसान नहीं है।

बेसिक्स के साथ शुरू करें, प्रदर्शन को कड़ी तरह से मापें, और आवश्यकताओं के अनुसार अपने आर्किटेक्चर को विकसित करें। यहां कवर किए गए उन्नत RAG वैरिएंट्स उस विकास के लिए एक रोडमैप प्रदान करते हैं।

उपयोगी लिंक्स

• पाइथन चीतशीट
• एम्बेडिंग मॉडल्स के साथ रीरैंकिंग
• LLMs और संरचित आउटपुट: ओल्लामा, क्वेन3 & पाइथन या गो
• क्लाउड LLM प्रोवाइडर्स
• LLMs तुलना: क्वेन3:30b vs GPT-OSS:20b

बाहरी संदर्भ

• माइक्रोसॉफ्ट ग्राफ़RAG: एक मॉड्यूलर ग्राफ़-आधारित रिट्रीवल-ऑगमेंटेड जेनरेशन सिस्टम
• Self-RAG: स्व-चिंतन के माध्यम से रिट्रीवल, जेनरेशन, और समीक्षा सीखना
• LongRAG: लंबे-कंटेक्स्ट LLMs के साथ रिट्रीवल-ऑगमेंटेड जेनरेशन को बढ़ाना
• लार्ज लैंग्वेज मॉडल्स के लिए रिट्रीवल-ऑगमेंटेड जेनरेशन: एक सर्वे
• FAISS: एफिशिएंट सिमिलारिटी सर्च के लिए एक लाइब्रेरी
• LangChain डॉक्युमेंटेशन: उन्नत RAG तकनीकों
• हगिंगफेस: एम्बेडिंग मॉडल्स के लिए सेंटेंस ट्रांसफॉर्मर्स
• RAG सर्वे: रिट्रीवल ऑगमेंटेड जेनरेशन का व्यापक विश्लेषण