आपका RG तंत्र "ol" प्रश्नों में महान है: कुछ संबंधित संबंधित संयोजन और जवाब प्राप्त करें. यह दो आम क्वैरी प्रकार के साथ संघर्ष करता है:

समझ में आता है: "इस क्रेकरुस के पार मुख्य प्रसंग क्या हैं?"
फिर से कनेक्ट करें: " X कैसे अलग अलग दस्तावेज़ों के पार Y से संबंधित है?"

वे किसी भी एक टुकड़ा द्वारा जवाब नहीं दिया जाता है, वे आवश्यकता है स्लाइडिंग + क्लैचिंग + लिंकिंग.

सदिश खोज यहाँ असफल हो गया:

और (मौत की तकलीफ़ से) पिन्डली से पिन्डली लिपट जाएगी स्वतंत्र क्वैरी में समानता से
एपॉसिटिस इमल्शन्स, नहीं वैश्विक विस्तार
"क्या समान आवाज" कैप्चर करता है, नहीं "क्या इससे जुड़ता है"

आप इन बलों और डाक प्रक्रिया के साथ यह बना सकते हैं, लेकिन आप एक ग्राफ-चक समाधान का अंत कर देते हैं।

मुख्य अन्तर्दृष्टि: ग्राफ REGRG इकाई बदलता है. crorrrobs सवालों के लिए आप "B-K-Ke-Ks" के लिए नहीं करना चाहते हैं; आप चाहते हैं कि आप "T-K-Ke-Kons" के लिए चाहते हैं जुड़ा हुआ विचार समुदाय फिर उसे ख़ूब घना और हरा-भरा कर दिया

ग्राफआरएजीGenericName Microsoft अनुसंधान से आता है कागज और वह ऐसा हो गया जैसे कटी हुई फ़सल ओपन-source कार्यान्वयन. यह विशिष्ट सवालों के लिए वेक्टर खोज जारी रखता है, लेकिन एक ज्ञान ग्राफ और समुदाय को casors-levels तर्क के लिए एक ज्ञान ग्राफ जोड़ता है।

जब ग्राफआरईजी इस्तेमाल नहीं करें

इससे पहले, यह है कि जब यह है के बारे में स्पष्ट हो जाएगा:

छोटा दस्तावेज़ सेट ( अवयव ~50 दस्तावेज़: सिर्फ वेक्टर खोज का इस्तेमाल करें)
केवल "मैं कैसे" सवाल करता हूँ: ग्राफAG मदद नहीं करेगा
एकसार सामग्री (कोई एंटिटी भिन्‍न नहीं: उपयोग करने के लिए कोई ग्राफ संरचना नहीं
लागत- धन युक्त: सूचििंग को कई देर तक कॉल की आवश्यकता है

यदि आपके उपयोक्ता सिर्फ विशिष्ट प्रश्न पूछें, के साथ जुड़े रहें तंत्र खोजGenericNameजब उपयोक्ता की आवश्यकता होती है तो ग्राफ- RaG प्रकाश बड़ी छवि, और कि एक छोटे से दर्शकों के सुझाव की तुलना में है.

परिचय

श्रेणी नेविगेशन: यह RAG श्रृंखला का भाग है:

भाग 1: उद्‌गम और मूलतत्त्ववाद - इतिहास, प्रेरणा, और मुख्य धारणाएँ
पार्ट 2: अ- धातु और आंतरिक - तकनीकी गहरी गति
अभ्यास में भाग 3: RAG - असली सिस्टम बना रहा है
पार्ट ४डी: एनएनएक्स व क्यूड कार्यान्वयन पर - सीपीयू- मित्रीय खोजQuery
भाग ४ख: कार्य में सेप्टिक खोज - टाइप हेड, ओपन- पीजीपी खोज, और यूआई
पार्ट 5: Hybd खोज स्वचलित किया जा रहा है - उत्पाद एकीकरण
पार्ट 6: ग्राफआरईजी ( इस लेख में) - कप्पे- लेवल्स समझ के लिए ज्ञान ग्राफ

इस श्रृंखला के माध्यम से, हम और अधिक जटिल RG सिस्टम बनाया है। हम मूल सदिश खोज के साथ शुरू किया है, जोड़े गए scirigial sigigial sting, और स्वचालित संग्रह। लेकिन इन सभी के पास एक बुनियादी सीमा का हिस्सा है: वे पाते हैं कि हम क्या कर रहे हैं। समान री- सलेक्ट, नहीं जुड़ा हुआ धारणाएँके लिए कोंपिस- लेवल्स ( लेखबद्ध अनेक दस्तावेज़ों को तैयार करने के लिए आपको संरचना की ज़रूरत है) ।

अनुशंसित पथ: यदि आप पहले से ही स्थानीय खोज रहे हैं (जैसे कि हम कर रहे हैं), पायथन साइडकार के साथ गहराई तक स्थानीय खोज मूल्य वैध करने के लिए, स्थानीय खोज के लिए जा रहे हैं, और वैश्विक / DRFTTTET के लिए एक ग्राफ जोड़ें। केवल जाओ केवल एक बार आप इन प्रश्नों से पूछ रहे हैं।

शुद्ध सदिश रेजी के साथ समस्या

मुझे तुम्हें दिखाने के लिए मैं एक ठोस उदाहरण के साथ क्या मतलब है।

सदिश रेफ़ क्या करता है

प्रश्न: "मैं एक अमिट्स के साथ HMMMX का उपयोग कैसे करते हैं?"

वेक्टर RAG प्रक्रिया:

इस सवाल का अंदाज़ा लगाइए: [0.234, -0.891, 0.567, ...]
जोडीयॉं ढुॅंढे
HMMX तथा आगामी के बारे में वापसी शीर्ष-के मेल
जो बिखरे हुए भाग से उत्तर

यह कार्य इसलिए करता है क्योंकि प्रश्न और संबंधित सामग्री हैं इसी तरह की ज़्यादतीइसमें कोई शक नहीं कि इसमें कोई फर्क नहीं है ।

// This is what our current SemanticSearchService does
var embedding = await _embeddingService.GetEmbeddingAsync(query);
var results = await _qdrantService.SearchAsync(
    collectionName: "blog_posts",
    queryVector: embedding,
    limit: 10
);
// Returns chunks about HTMX, Alpine.js, frontend patterns

जहाँ सदिश रेजी संघर्ष करता है

प्रश्न: "क्या मुख्य तकनीक मैं के बारे में लिख रहे हैं और कैसे वे एक दूसरे से संबंधित हैं?"

क्या सदिश RG लौटाता है:

Result 1: "HTMX makes it easy to add AJAX to your pages..."
Result 2: "Docker Compose orchestrates multiple containers..."
Result 3: "PostgreSQL's full-text search is surprisingly capable..."
Result 4: "Alpine.js provides reactive state management..."

यह डॉकर, HMAX, HMAX, पर उल्लेख करता है ... लेकिन उन्हें समूह नहीं है या वे कैसे कनेक्ट करते हैं. आप टुकड़े मिल जाता है, अन्तर्दृष्टि नहीं.

समस्या: यह सवाल करने की ज़रूरत है रीग्रेसन तथा रिश्‍ते समझ पूरे क्रेकर के पार. आप की जरूरत है:

सभी तकनीकों को पहचानें जिनका ज़िक्र किया गया है
समझ रहें हैं वे जो एक साथ इस्तेमाल किए जाते हैं
उन्हें व्यक्तिगत प्रसंग में समूहबद्ध करें

सदिश समानता केवल आपको यह नहीं दे देता है. यदि आप इन आयात से पैच करने की कोशिश करते हैं, तो आप अंत में एक ग्राफ का पुनःप्रयोग करते हैं.

ग्राफ- आरईजी भरें

ग्राफआरएजीGenericName Microsoft अनुसंधान का समाधान इस समस्या के लिए है. ग्राफ- RG कागज दो क्वेरी क़िस्म की पहचान कि बेसलाइन रे खराब करता है (e)समझ में आता है और जुड़ रहे (S)) और विशेष रूप से उन्हें पता करने के लिए एक प्रणाली बनाया.

सिर्फ स्कैन करने के बजाय, ग्राफRG एक बनाता है ज्ञान ग्राफ इस वजह से उनके आपसी रिश्‍ते और उनके रिश्‍ते टूट जाते हैं ।

ग्राफक काम कैसे करता है

एक दृष्टि पर पाइपलाइन:

निर्देशिका बनाई जा रही है: Doeksepeosepes/Xsepes
क्वेरी: स्थानीय = रीग्रेस + ग्राफ आयामी वैश्विक = समुदाय एसआईएस डीआरआईटीT = पथ + squgress

ग्राफRAG RGERAR के कई घटकों को जोड़ता है, समूह तीन वर्गों में समूह:

निकालें (संयोगियां + सम्बन्धों)
ग्राफ बिल्ड (ज्ञान ग्राफ भंडार)
प्रचार (कलाकार जांच + पदक्रम)

flowchart TB
    subgraph "Traditional RAG (What We Have)"
        A[Documents] --> B[Chunks]
        B --> C[Embeddings]
        C --> D[Vector Store]
    end

    subgraph "GraphRAG Additions"
        B --> E[Entity Extraction]
        E --> F[Relationship Extraction]
        F --> G[Knowledge Graph]
        G --> H[Community Detection]
        H --> I[Community Summaries]
    end

    subgraph "Query Time"
        J[User Query] --> K{Query Type?}
        K -->|Specific| L[Local Search]
        K -->|Global| M[Global Search]
        K -->|Hybrid| N[DRIFT Search]

        D --> L
        G --> L
        I --> M
        G --> N
        I --> N
    end

    style E stroke:#f9f,stroke-width:2px
    style H stroke:#bbf,stroke-width:2px
    style I stroke:#9f9,stroke-width:2px

चरण 1: एंटिटी निकालें

एक LLM हर बार और निकालने के लिए पढ़ता है एंटिटी (बाज़ को माना बाज को नहीं) तो ऐ रसूल तुम्हारे ही परवरदिगार की (अपनी) क़सम

Chunk: "Docker Compose makes it easy to define multi-container applications.
        I use it with PostgreSQL for my blog's database layer."

Extracted Entities:
- Docker Compose (technology)
- PostgreSQL (database)
- blog (project)
- database layer (concept)

चरण 2: संबंधता

उसीलीम पहचानती है कि निगम कैसे एक दूसरे से जुड़े होते हैं:

Relationships:
- Docker Compose --[used_with]--> PostgreSQL
- blog --[has_component]--> database layer
- PostgreSQL --[implements]--> database layer

चरण 3: ज्ञान ग्राफ निर्माण

सभी एंटिटी तथा संबंध एक ग्राफ बनाते हैं:

graph LR
    subgraph "Frontend Cluster"
        HTMX[HTMX]
        Alpine[Alpine.js]
        Tailwind[Tailwind CSS]
    end

    subgraph "Infrastructure Cluster"
        Docker[Docker]
        Compose[Docker Compose]
        Postgres[PostgreSQL]
        Qdrant[Qdrant]
    end

    subgraph "AI/ML Cluster"
        ONNX[ONNX Runtime]
        Embeddings[Embeddings]
        RAG[RAG]
    end

    HTMX -->|used_with| Alpine
    HTMX -->|styled_by| Tailwind
    Alpine -->|styled_by| Tailwind

    Docker -->|orchestrated_by| Compose
    Compose -->|runs| Postgres
    Compose -->|runs| Qdrant

    ONNX -->|generates| Embeddings
    Embeddings -->|stored_in| Qdrant
    RAG -->|uses| Embeddings
    RAG -->|uses| Qdrant

    style HTMX stroke:#f9f
    style Docker stroke:#bbf
    style RAG stroke:#9f9

चरण ४: समुदाय का पता लगाना (लिडियन एल्गोरिदम)

वह लडेन एल्गोरिदम ( ख) हम इस लेख में किन बातों पर चर्चा करेंगे? स्थिर ये झुंड दुनिया - भर की चीज़ों के लिए आपकी वापसी इकाई बन जाते हैं ।

टिप्पणी १: "फ्सेन्ट स्टैक" (HMX, Ajass. )
टिप्पणी २: "स्टोरर इन्फस्फीयर" (डेकर, डिजाइन, एसक्यूएल, क्यूरेशन)
समुदाय ३: "RAG lineline" (NX, एम्बेडिंग, क्यूवेशन, RAG)

ध्यान दीजिए कि कैसे क्यूडमेंट दो समुदायों में प्रकट होता है: यह पुल अफ्रालास और एआई/एमएल में है.

चरण 5: समाज - विरोधी

एक TLM प्रत्येक वर्ग के लिए प्रत्येक समुदाय के लिए समाधान बनाता है:

Community 1 Summary (Frontend Stack):
"The frontend approach combines HTMX for server-driven interactivity
with Alpine.js for client-side state management, styled using Tailwind CSS.
This stack prioritizes HTML-first development with minimal JavaScript,
focusing on progressive enhancement over SPA complexity."

Community 2 Summary (Container Infrastructure):
"The blog runs on Docker Compose, orchestrating PostgreSQL for persistent
storage, Qdrant for vector search, and the ASP.NET Core application.
This containerized architecture enables consistent local development
and production deployment."

क्वैरी मोड

ग्राफRAG तीन क्वैरी मोड प्रदान करता है, प्रत्येक अलग प्रश्न क़िस्म के लिए स्तर निर्धारित करता है:

वैश्विक खोज

के लिए उत्तम: " मुख्य प्रसंग क्या हैं?" " कुंजी विषय को स्पष्ट करें।"

इन सवालों का सही - सही जवाब देने के लिए समुदाय की जाँच (जो व्यक्‍तिगत रूप से अलग नहीं है) का इस्तेमाल करता है:

Query: "What technologies does this blog cover most?"

Process:
1. Retrieve all community summaries
2. Map: Ask LLM to extract technology themes from each summary
3. Reduce: Combine partial answers into final response

Response:
"The writing centres on three technology clusters:
1. **Frontend Development** - HTMX, Alpine.js, Tailwind CSS for minimal-JS web UIs
2. **AI/ML Infrastructure** - RAG pipelines, ONNX embeddings, vector search with Qdrant
3. **DevOps/Containerization** - Docker, PostgreSQL, ASP.NET Core deployment"

स्थानीय खोज

के लिए उत्तम: "मैं X कैसे विन्यस्त करें?" " Y क्या है?"

संयुक्त एंटिटी- सरल ग्राफ पारंपरिक वेक्टर खोज के साथ सामान्य- संवाद:

Query: "How do I use Qdrant with ONNX embeddings?"

Process:
1. Identify entities in query: Qdrant, ONNX, embeddings
2. Retrieve graph neighborhood around those entities
3. Also retrieve vector-similar chunks
4. Combine into rich context for LLM

Response includes:
- Direct relationships (ONNX generates embeddings stored in Qdrant)
- Related entities (all-MiniLM-L6-v2 model, cosine similarity)
- Specific code examples from vector-retrieved chunks

डीआरआईएफई खोजComment

के लिए उत्तम: "कैसे X Y से संबंधित है?" "कोम्पर ए और बी"

DRFET खोज (अनुप्रयोगात्मक जोखिमों से और गुण), के रूप में ग्राफ- RGss में वर्णित, स्थानीय खोज को समुदाय के संदर्भ के साथ जोड़ता है. यह अभी भी RLM तर्क का उपयोग कर रहा है RLM संदर्भ में वापस संदर्भ (यह जादू ग्राफ नहीं है), लेकिन संरचना देखने में कनेक्शनों की कमी होगी.

Query: "How do the frontend and backend technologies connect?"

Process:
1. Start with entities: HTMX, ASP.NET Core
2. Traverse graph to find connection paths
3. Include community summaries for context
4. Generate answer showing the full picture

Response:
"HTMX makes requests to ASP.NET Core endpoints, which query PostgreSQL
and Qdrant. The connection flows through the API layer, where endpoints
return HTML fragments that HTMX swaps into the DOM. Alpine.js handles
client-side state for interactive components like search typeahead."

अपने मौज़ूदा तंत्र के लिए ग्राफआरईजी की तुलना करना

चलो हम पहले से ही क्या है के लिए ग्राफ RagaG धारणाएँ नक्शे करें Mostlylucid.SemanticSearch:

Alivon अवयव मौजूदा तंत्र 0. gRAGquefon |-----------|---------------|---------------------| | एम्बेडिंग INNX (सभी- माही-L6- v2) समान (या खोलें) | सदिश भंडारित 20वीं सदी के बीच हुई घटनाओं के बारे में क्या कहा जा सकता है? | एंटिटी निकालें DELLLLLLM- ऊर्जा | ज्ञान ग्राफ IMTAN ग्राफ डाटाबेस / mmiodio | समुदाय पता लगाएँ INNT कुछ नहीं Loiden एल्गोरिदम | प्रश्न: विशिष्ट | SemanticSearchService.SearchAsync() काफिर स्थानीय खोज बराबर है | प्रश्न: वैश्विक Libisofs का समर्थन नहीं करता है

हमारा वर्तमान कार्यान्वयन हैंडल करता है स्थानीय खोज अच्छी तरह से. ग्राफईजी जोड़ें वैश्विक खोज और डीआरआईएफई खोजComment क्षमता.

// What we have today (Local Search equivalent)
public async Task<List<SearchResult>> SearchAsync(string query, int limit = 10)
{
    var embedding = await _embeddingService.GetEmbeddingAsync(query);
    return await _qdrantService.SearchAsync("blog_posts", embedding, limit);
}

// What GraphRAG would add
public async Task<string> GlobalSearchAsync(string query)
{
    // 1. Retrieve community summaries (not chunks)
    var summaries = await _graphService.GetCommunitySummariesAsync();

    // 2. Map: Extract relevant themes from each summary
    var partialAnswers = await Task.WhenAll(
        summaries.Select(s => _llm.ExtractThemesAsync(query, s))
    );

    // 3. Reduce: Combine into final answer
    return await _llm.SynthesizeAsync(query, partialAnswers);
}

कार्यान्वयन परिणाम

एक मौजूदा तंत्र में ग्राफRAG जोड़ने के तीन तरीके हैं.

विकल्प 1: पायथन साइड्कर (प्रयोग के लिए रीग्रेसन्ड)

माइक्रोसॉफ़्ट ग्राफAG को एक अलग सेवा के रूप में चलाएँ:

# docker-compose.graphrag.yml
services:
  graphrag:
    build:
      context: ./graphrag
    volumes:
      - ./data/input:/app/input
      - ./data/output:/app/output
    environment:
      - OPENAI_API_KEY=${OPENAI_API_KEY}

  graphrag-api:
    build:
      context: ./graphrag-api
    ports:
      - "8001:8000"
    depends_on:
      - graphrag

// GraphRagClient.cs - Call from ASP.NET Core
public class GraphRagClient
{
    private readonly HttpClient _http;

    public GraphRagClient(HttpClient http)
    {
        _http = http;
        _http.BaseAddress = new Uri("http://graphrag-api:8000");
    }

    public async Task<string> GlobalSearchAsync(string query)
    {
        var response = await _http.PostAsJsonAsync("/query/global", new { query });
        var result = await response.Content.ReadFromJsonAsync<GraphRagResponse>();
        return result.Answer;
    }

    public async Task<string> LocalSearchAsync(string query)
    {
        var response = await _http.PostAsJsonAsync("/query/local", new { query });
        var result = await response.Content.ReadFromJsonAsync<GraphRagResponse>();
        return result.Answer;
    }
}

प्रोविडेंस: Microsoft के युद्ध-आउट कार्यान्वयन का प्रयोग करें, जो कि हाल्ट के लिए त्वरित है कनेक्शनः पायथन एक्सप्रेशन, सूचीिंग के लिएLM लागत, पार- प्रक्रिया संचार

विकल्प 2: .ENT नेटिव (प्रयोग पथ)

C# में कुंजी अवयव बिल्ड करें. artटी आधारित मानक आधारित तथा ओएलमा पैटर्न से दो- आयतन्जर उसी तरह यहाँ काम करते हैं.

एंटिटी निकालें

पहचान के लिए किसी कार्ड से पूछें चीज (प्रयोगात्मक विषयों के बजाए प्रत्येक भाग में:

public async Task<List<Entity>> ExtractEntitiesAsync(string chunk)
{
    var prompt = $"""
        Extract entities from this text. Return JSON array.
        Types: technology, concept, project, person, organization
        Text: {chunk}
        Format: [{{"name": "Docker", "type": "technology"}}]
        """;

    var response = await _ollama.GenerateAsync(prompt);
    return JsonSerializer.Deserialize<List<Entity>>(response);
}

उत्पादन आवश्‍यक: LM JSON आउटपुट होगा टूटिए. यह कठोर नहीं है. आपको एक की आवश्यकता है:

प्रसंग युक्त पीढ़ी (Ololans) format: json, LOAL के फंक्शन बुला रहा है
निर्माण लूपों के साथ फिर से कोशिश करें ( विरूपित JSON, इसे ठीक करने के लिए पूछें)
फालबैक सामान्य एंटिटी क़िस्म के लिए किनारा पैटर्न (e)

आपकी निकासी नहीं होनी चाहिए ।

संबंधता

एक बार आपके पास निगम हैं, पूछ लो कि वे कैसे कनेक्ट हैं:

public async Task<List<Relationship>> ExtractRelationshipsAsync(
    string chunk, List<Entity> entities)
{
    var names = string.Join(", ", entities.Select(e => e.Name));
    var prompt = $"""
        Given entities: {names}
        Extract relationships. Return JSON array.
        Text: {chunk}
        Format: [{{"source": "Docker", "target": "PostgreSQL", "rel": "runs"}}]
        """;

    return JsonSerializer.Deserialize<List<Relationship>>(
        await _ollama.GenerateAsync(prompt));
}

एंटिटी बिना सामान्यता के साथ ग्राफ भंडारण

सबसे बड़ा व्यावहारिक दर्द है एंटिटी अलियास: "Sue. Nint", "Seche. N.nett", और "apperpons" एक ही नोड होना चाहिए. सरल सामान्यकरण मदद:

public class KnowledgeGraph
{
    private readonly Dictionary<string, Entity> _entities = new();
    private readonly List<Relationship> _relationships = new();

    public void AddEntity(Entity entity)
    {
        var key = Normalise(entity.Name);  // "ASP.NET Core" → "aspnetcore"
        _entities[key] = entity;
    }

    private string Normalise(string name) =>
        name.ToLowerInvariant().Replace(".", "").Replace("-", "").Trim();
}

गंभीर उपयोग के लिए, maciod-परेशन डिडिडिडिशन पर विचार करें: यदि दो एंटिटी नाम समान हैं, तो वे शायद एक ही बात कर रहे हैं.

उत्पाद दर्द बिन्दु (ग्राफRG का मूल्य ग्राफ गुणवत्ता पर निर्भर करता है):

साइन्सनम/ अलाएस तालिका: केनोनिकल नाम और जाने - माने उपनामों को बनाए रखिए
संबंधता स्कीमा नियंत्रण: गलत रिश्‍तों के प्रकारों को रोकने के लिए बाध्य करता है
भरोसे की कमी + हंसना: सभी निकाले गए रिश्‍ते समान विश्‍वसनीय नहीं हैं
INVERACKS री-शोथिंग: जब दस्तावेज़ अद्यतन करें, आप ग्राफ को पैच करने की जरूरत नहीं है, इसे फिर से बनाएं नहीं

ग्राफ ट्रेल

सम्बन्धित एंटिटी खोज

public List<Entity> GetNeighbors(string entityName, int depth = 1)
{
    var result = new HashSet<Entity>();
    var queue = new Queue<(string Name, int Depth)>();
    queue.Enqueue((Normalise(entityName), 0));

    while (queue.Count > 0)
    {
        var (name, d) = queue.Dequeue();
        if (d >= depth) continue;

        // Find all entities connected to this one
        var neighbours = _relationships
            .Where(r => Normalise(r.Source) == name || Normalise(r.Target) == name)
            .SelectMany(r => new[] { r.Source, r.Target });

        foreach (var neighbour in neighbours)
            if (_entities.TryGetValue(Normalise(neighbour), out var entity))
                if (result.Add(entity))
                    queue.Enqueue((Normalise(neighbour), d + 1));
    }
    return result.ToList();
}

समुदाय पता लगाएँ

यह एक जुड़े हुए अवयव बेसलाइन है, नहीं पूर्ण Lideen. लेडिन sideivien side ( आंतरिक कनेक्शनों के लिए, sundits). एक उचित कार्यान्वयन पुस्तकालय या पोर्ट एल्गोरिथ्म के लिए इस्तेमाल करें.

public List<Community> DetectCommunities(KnowledgeGraph graph)
{
    // Connected components: group everything reachable together
    var visited = new HashSet<string>();
    var communities = new List<Community>();

    foreach (var entity in graph.GetAllEntities())
    {
        if (visited.Contains(entity.Name)) continue;
        
        // BFS to find all connected entities
        var community = new Community();
        var queue = new Queue<string>();
        queue.Enqueue(entity.Name);

        while (queue.Count > 0)
        {
            var name = queue.Dequeue();
            if (!visited.Add(name)) continue;
            community.Entities.Add(graph.GetEntity(name));
            foreach (var neighbor in graph.GetNeighbors(name, depth: 1))
                queue.Enqueue(neighbor.Name);
        }
        communities.Add(community);
    }
    return communities;
}

समाज प्रचार

हर समुदाय के अपने विषय का सारांश हो जाता है. यह शक्‍तियों को खोजता है:

public async Task<string> SummarizeCommunityAsync(Community community)
{
    var entities = string.Join("\n", 
        community.Entities.Select(e => $"- {e.Name}: {e.Description}"));
    
    var prompt = $"""
        Summarize what unites these concepts (2-3 sentences):
        {entities}
        """;

    return await _ollama.GenerateAsync(prompt);
}

विकल्प ३: हाइब्रीड (कैर्म्ड मध्य ग्राण्ड)

यह सलाह दी जाती है यदि आप पहले से ही काम कर रहे वेक्टर खोज कर रहे हैं. स्थानीय खोज के लिए क्यूडवर रखें, वैश्विक/DIT जांच के लिए एक हल्का ग्राफ परत जोड़ें.

क्वैरी वर्गीकरण

पहला, पता लगाइए कि यह किस तरह का सवाल है:

// WARNING: Toy heuristic for illustration only.
// In production, use a classifier prompt or few-shot rules and log misroutes.
private QueryMode ClassifyQuery(string query)
{
    var q = query.ToLowerInvariant();
    
    if (q.Contains("main theme") || q.Contains("summarize") || q.Contains("what topics"))
        return QueryMode.Global;
    
    if (q.Contains("relate") || q.Contains("connect") || q.Contains("compare"))
        return QueryMode.Drift;
    
    return QueryMode.Local;
}

स्थानीय सर्च (एनएनईएसडी)

मौजूदा सदिश खोज का प्रयोग करें, वैकल्पिक रूप से उपयोगी

private async Task<string> LocalSearchAsync(string query)
{
    // Existing semantic search (what we have today)
    var chunks = await _semanticSearch.SearchAsync(query, limit: 10);

    // NEW: Enrich with related entities from graph
    var entities = await _graphService.ExtractEntitiesFromQueryAsync(query);
    var related = await _graphService.GetEntityContextAsync(entities);

    return await _llm.GenerateAsync(query, FormatContext(chunks, related));
}

वैश्विक खोज (नया कैप्ससी)

समाज के सापेक्ष मैप खोजें (कोई सदिश खोज आवश्यक नहीं):

private async Task<string> GlobalSearchAsync(string query)
{
    var summaries = await _graphService.GetAllCommunitySummariesAsync();

    // Map: Extract relevant info from each community
    var partials = await Task.WhenAll(
        summaries.Select(s => _llm.ExtractRelevantInfoAsync(query, s)));

    // Reduce: Combine into final answer
    return await _llm.SynthesizeAsync(query, partials.Where(p => !string.IsNullOrEmpty(p)));
}

DRFT खोज (एनआईटीएओएटर)

"x" के लिए समुदाय के संदर्भ के साथ अपने स्थानीय परिणाम सम्मिलित करें

private async Task<string> DriftSearchAsync(string query)
{
    var localResults = await LocalSearchAsync(query);
    
    var entities = await _graphService.ExtractEntitiesFromQueryAsync(query);
    var communities = await _graphService.GetCommunitiesForEntitiesAsync(entities);
    var themes = string.Join("\n", communities.Select(c => c.Summary));

    return await _llm.GenerateAsync(
        $"Question: {query}\n\nDetails:\n{localResults}\n\nBroader themes:\n{themes}",
        systemPrompt: "Synthesize the details with the thematic context.");
}

लागत तथा परफ़ॉर्मेंस विश्लेषण

ग्राफ RAG महत्वपूर्ण व्यापार बंद है शुद्ध सदिश RAG की तुलना में।

सूची कास्टिंग लागत

एंटिटी/पुनंपरेशन केवल मॉडल, तत्काल डिजाइन और आकार से भिन्न होते हैं. एक छोटे से अनुक्रम की तुलना में, मान लीजिए. एक या दोL कॉल प्रति मिनट इसके अलावा, अलग - अलग समाजों के लिए छोटी - छोटी माँगें भी हैं ।

नाहक़ कार्रवाई सदिश RAGRGERAR |-----------|------------|----------| | एम्बेडिंग STAN 1 काल/क कूटक उसी तरह | एंटिटी/ त्रिज्या निकाला जा रहा है IMTAN 1- 2L कॉल/कंक | समाज प्रचार IMTAN 1LL कॉल/ रहता है

1,000 ब्लॉग पोस्टों के लिए 5 में से एक के लिए प्रत्येक में 5 का कुल है, सदिश - केवल सूची बनाने का खर्च है. ग्राफAG हज़ारों की आवश्यकताओं को एनएएम कॉल के लिए कॉल करता है. सही मूल्य पर निर्भर करता है अपने आदर्श और अनिवार्य क्षमता पर भारी कीमत पर, स्थानीय मॉडलों का उपयोग करते हैं (ओएस2 के साथ) इसी तरह का उपयोग करने की सिफारिश की जाती है.

क्वैरी कास्ट

Gdk क्वेरी वेक्टर RGRGRAGLLARARGEAGRGEAL |------------|------------|----------------|-----------------| | सदिश खोज SHA 1 कॉलेल 1 कॉल 0. 0 कॉल को कुल रहता है | ग्राफ सायकलल IMSEX 0- 26- 2 खथथथ- 0. 0 | कॉल IMTAL( 2- 2"; 1 (मानचित्र) + 1 (अंग्रेड)

वैश्विक खोज प्रति क्वैरी अधिक लागत है, लेकिन यह सवालों का जवाब है कि स्थानीय खोज सिर्फ नहीं कर सकते हैं. आप भी वैश्विक उत्तर दे सकते हैं और तभी उन्हें ताज़ा कर सकते हैं जब case परिवर्तन हो.

ग्राफRAG विफलता मोड

ग्राफ REG जादू नहीं है. के लिए देखो:

निकाला गया त्रुटि: अगर आपको लगता है कि आपके रिश्‍ते में दरार आ गयी है या आपका आपसी रिश्‍ता खराब हो गया है
एंटिटी उपनाम: "Sue. NonT" vse. sec" vs "सम्पोकर" अलग नोड्स हो जाते हैं
ग्राफ बहाव: जब डॉट्स अद्यतन किया जाए, ग्राफ एक्सप्लोर हो सकता है
समाज में बदलाव: जब निगम बदलता है तो सारस स्वचालित अद्यतन नहीं करता

एंटिटी कोई सामान्य रूप से सबसे बड़ा व्यावहारिक दर्द है. आप की आवश्यकता होगी:

वृत्तीय नाम + उपनाम
केस- स्केलिंग तथा समसंपादन कोई सामान्यीकरण नहीं
वैकल्पिक रूप से एम्बेड्ड एंटिटी डीडीएडी

हमारी ब्लॉग खोज के साथ मूल्यांकन किया जा रहा है

यहाँ कैसे ग्राफीजी ब्लॉग के मौजूदा खोज को बढ़ा सकता है:

वर्तमान प्रवाह

User types in search → SemanticSearchService → Qdrant → Results

तुम्हें एक-दूसरे के मुक़ाबले में एक-दूसरे से पूछना होगा.

वर्गीय मार्ग विभिन्न खोज योजनाओं के लिए. यहाँ कैसे एक है वैश्विक क्वैरी प्रवाहित करता है - नोट करता है कि यह कभी सदिश स्टोर को छू नहीं सकता:

sequenceDiagram
    participant U as User
    participant API as Search API
    participant C as Query Classifier
    participant G as Global Search
    participant KG as Knowledge Graph

    U->>API: "What topics does this blog cover?"
    API->>C: Classify query
    C-->>API: QueryMode.Global

    API->>G: GlobalSearch(query)
    G->>KG: GetCommunitySummaries()
    KG-->>G: [Frontend, Infrastructure, AI/ML]
    G->>G: MapReduce over summaries
    G-->>API: Synthesized answer

    API-->>U: "The blog covers three main areas..."

इसे तुलना करें स्थानीय क्वैरी, जो वेक्टर खोज को अमीर उत्तर के लिए ग्राफ संदर्भ के साथ जोड़ता है:

sequenceDiagram
    participant U as User
    participant API as Search API
    participant C as Query Classifier
    participant L as Local Search
    participant Q as Qdrant
    participant KG as Knowledge Graph

    U->>API: "How do I use HTMX?"
    API->>C: Classify query
    C-->>API: QueryMode.Local

    API->>L: LocalSearch(query)
    L->>Q: Vector search
    Q-->>L: Relevant chunks
    L->>KG: GetEntityContext("HTMX")
    KG-->>L: Related: Alpine.js, Tailwind, ASP.NET
    L-->>API: Answer with rich context

    API-->>U: "HTMX is used with Alpine.js for..."

मुख्य अंतर: दुनिया - भर में जनीकरण समुदाय (कंकरी- लेवल प्रसंग), जबकि स्थानीय लोग एंटिटी संबंधों के साथ समृद्ध विशेष रूप से प्राप्त करते हैं ।

सरल विकल्प: GRAG अभी भी एक शोध उपकरण - संरचनाएँ, ग्राफीय निर्माण, और समुदाय की जाँच उल्लेखनीय जटिलता और TLM लागत जोड़ती है । BERTiring + BM25 कीवर्ड मेल बढ़िया काम करो. यही है. स्रोतग्राफ का सेडी कोड समझ के लिए उपयोग में लें, और क्या दो- आयतन्जर दस्तावेज़ विश्लेषण के लिए उपयोग में. पैटर्न: salalaltssssssssss seks,LLM संभालता है सम्मेलन, नहीं निर्णय- बनाना. आप 20% जटिलता से लाभ प्राप्त करते हैं 80%.

कार्यान्वयन एसकेस्क

एपीआई सीधा है: क्वैरी को सुलझाने के लिए उचित हैंडलर के लिए मार्ग:

[HttpGet("api/search")]
public async Task<IActionResult> Search([FromQuery] string q, [FromQuery] string mode = "auto")
{
    if (mode == "auto")
        mode = ClassifyQuery(q);

    // global/local return synthesised answers; default returns raw search results
    return mode switch
    {
        "global" => Ok(await _graphRag.GlobalSearchAsync(q)),  // synthesised answer
        "local" => Ok(await SearchWithGraphContext(q)),        // answer with citations
        _ => Ok(await _semanticSearch.SearchAsync(q))          // raw ranked results
    };
}

सदिश खोज तथा ग्राफ खोज एक दूसरे से मेल खाते हैं. "मैं कैसे" प्रश्नों के लिए इस्तेमाल करें, ग्राफ "क्या प्रसंग हैं" प्रश्नों के लिए.

कंटेनमेंट

ग्राफ REG RG REG REG RAG RER से REG "जैसे ही ज्ञान संरचना के अधीन" के लिए "में ज्ञान का निर्माण करें" यह वेक्टर खोज के लिए कोई जगह नहीं है, यह एक सहायक है जो नए क्वैरी प्रकार सक्षम करता है.

ग्राफक आगे क्या बताता है:

एंटिटी तथा संबंध निकासक
ज्ञान ग्राफ निर्माण
समाज का पता लगाना और उनके बारे में सोच - समझकर फैसला करना
सवाल सुलझाने के लिए दुनिया की खोज
कनेक्ट करनेवाली दलील के लिए डीआरआईएफ़एस खोजName

कब इस्तेमाल किया जाए:

आपके पास पर्याप्त दस्तावेज़ संग्रह है.
उपयोक्ता पूछते हैं " प्रसंग क्या हैं" प्रकार के प्रश्न
आपकी धन - दौलत में साफ - सफाई और रिश्‍तों का आपसी रिश्‍ता है
आप स्वचालित कनेक्शन स्वतः सतह करना चाहते हैं

कार्यान्वयन पथ:

सबसे पहले, पूछिए: क्या आपको सचमुच इसकी ज़रूरत है?
यदि हाँ, पायथन साइडकार के साथ वैध मान करने के लिए
यदि खर्च / मुद्रा में हो तो निर्माण करें
सूची खर्च को नियंत्रित करने के लिए स्थानीय लेवेल्स (ओलाइमा) इस्तेमाल करें

संसाधन

ग्राफRG अधिकारी:

ग्राफआरएजी दस्तावेज़ीकरण - माइक्रोसॉफ्ट का अधिकारी डोम्स
ग्राफ- RGt Git - स्रोत कोड तथा उदाहरण
ग्राफ- RG कागज - मूल शोध कागज
लडेन एल्गोरिदम कागज - समुदाय का पता लगाने वाला एल्गोरिदम

RAGes:

सरल वैकल्पिक (BRT + BM25):

डोफ्ल्जर पार्ट ३ - ग्राफ के बगैर Hybd प्राप्ति
स्रोत जानकारी - उत्पाद विडगेट खोज

ग्राफ REG: क्यों सचिव स्तर पर सदिश खोज तोड़