# GraphRAG: कॉर्पस स्तर पर सदिश खोज क्यों टूटती है

<datetime class="hidden">2025-12-26T12:00</datetime>

<!-- category -- ASP.NET, Semantic Search, ONNX, Qdrant, Machine Learning, Vector Search, RAG -->
आपके RAG तंत्र में बहुत अच्छा है।

- **संवेदना निर्माण**कोर्स में मुख्य विषय क्या हैं
- **कनेक्टिव**क्या X विभिन्न दस्तावेजों में Y से संबंधित है

वे हैं-' कोई भी एकल टुकड़ा द्वारा जवाब नहीं देता है **कवरेज + क्लस्टरिंग**.

**यहाँ सदिश खोज क्यों असफल है**

- यह टुकड़े रैंक करता है **स्वतंत्र रूप से** क्वेरी के समानता से
- समानता प्रासंगिकता को बेहतर बनाती है **वैश्विक कवरेज**
- एम्बेडिंग कैप्चर "क्या ध्वनि समान होती है

You can brute-force this with prompting and post

**प्रमुख अंतर्दृष्टि** GraphRAG पुनर्प्राप्ति इकाई को बदलता है. कॉर्पस प्रश्नों के लिए आप नहीं चाहते हैं **संबद्ध अवधारणा समुदाय** (और उनके सारांशों), इस प्रकार मॉडल संरचना को देखता है

[ग्राफ आर ए जी](https://microsoft.github.io/graphrag/) माइक्रोसॉफ्ट रिसर्च से आता है [कागज](https://arxiv.org/pdf/2404.16130) और एक के रूप में उपलब्ध है [open-source कार्यान्वयन](https://github.com/microsoft/graphrag)यह विशिष्ट प्रश्नों के लिए भेक्टर खोज रखता है

**ग्राफRAG श्रृंखला नेविगेशन:**

- **भाग 1: GraphRAG मूलभूत** इस अनुच्छेद
- [भाग 2: न्यूनतम व्यावहारिक ग्राफRAG](/blog/graphrag-minimum-viable-implementation)

## जब ग्राफराग का उपयोग न करें

में डुबोने से पहले यह स्पष्ट करें कि क्या यह अधिमार है

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

यदि आपके उपयोक्ता केवल विशिष्ट प्रश्न पूछते हैं [अर्थिक खोज](/blog/semantic-search-with-onnx-and-qdrant). GraphRAG चमकता है जब उपयोगकर्ताओं के लिए आवश्यक *बड़ा चित्र*0 और यह कि एमएसके1 विक्रेताओं की सिफारिश से कम श्रोता है

# परिचय

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

- [भाग 1: मूल और बुनियादी](/blog/rag-primer) - इतिहास
- [भाग 2: वास्तुकला और आंतरिक](/blog/rag-architecture) - तकनीकी गहरी डुबोई
- [भाग 3: RAG व्यावहारिक में](/blog/rag-practical-applications) - वास्तविक प्रणाली निर्माण
- [भाग 4a: ONNX & Qdrant कार्यान्वयन](/blog/semantic-search-with-onnx-and-qdrant) - सीपीयू
- [भाग 4b: क्रिया में सेमेटिक खोज](/blog/semantic-search-in-action) - टाइपेहेड, हाइब्रिड खोज
- [भाग 5: हाइब्रिड खोज](/blog/rag-hybrid-search-and-indexing) - उत्पादन एकीकरण
- **भाग 6: GraphRAG** (इस अनुच्छेद के लिए ज्ञान ग्राफ्स

इस श्रृंखला के दौरान-,-हम-'-हम अधिक विकसित RAG प्रणालियों का निर्माण किया है। .-हम बुनियादी भेक्टर खोज से आरंभ कर दिया गया था. ,-हम हाइब्रिड शब्दकुञ्जी जोड़ा. **समान टुकड़े**, नहीं **संबद्ध संकल्पनाएं**के लिए *कोरस* सवाल ( अनेक दस्तावेजों को शामिल करने वाले विषयों के लिए ) आपको संरचना की जरूरत है

**सिफारिशित पथ:** यदि आपके पास पहले से Qdrant-आधारित स्थानीय खोज कार्य कर रहा है (जैसा हम करते हैं-जैसे हम मान को सत्यापित करने के लिए पाइथोन साइडकार के साथ ),प्रोटोटाइप बनाते हैं।

[TOC]

# शुद्ध भेक्टर RAG के साथ समस्या

मैं आपको एक ठोस उदाहरण के साथ क्या मतलब बता दूँगा

## वेक्टर RAG क्या अच्छा करता है

**प्रश्न** मैं Alpine के साथ HTMX का उपयोग कैसे करता हूँ

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

1. प्रश्न को अंतःस्थापित करें `[0.234, -0.891, 0.567, ...]`
2. Qdrant में समान टुकड़े ढूंढें
3. HTMX और Alpine के बारे में मैच
4. एलएलएम उन टुकड़ों से जवाब संश्लेषित करता है

यह काम करता है क्योंकि प्रश्न और प्रासंगिक सामग्री हैं **अर्थिक रूप से समान**. एम्बेडिंग उस समानता को ग्रहण करता है

```csharp
// 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
```

## जहाँ भेक्टर आरएजी संघर्ष करता है

**प्रश्न** के बारे में मैं क्या मुख्य प्रौद्योगिकी लिखता हूँ और वे एक-दूसरे से कैसे संबंधित हैं

**What vector RAG returns:**

```
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..."
```

यह Docker इंगित करता है, PostgreSQL | , | HTMX |, | ONNX | МSK3 | लेकिन यह उन्हें समूह नहीं देता या यह बताता है कि वे कैसे जोड़ते हैं

समस्या: इस प्रश्न को आवश्यक है **आकलन और संबंध समझ** पूरे कोर्स के माध्यम से

- सभी उल्लेखित प्रौद्योगिकियों को पहचानें
- उन चीजों को समझें जो एक साथ इस्तेमाल की जाती हैं
- उन्हें सुसंगत विषयों में समूहित करें

सिर्फ भेक्टर समानता आपको यह नहीं देता

# ग्रैफआरएजी प्रविष्ट करें

[ग्राफ आर ए जी](https://microsoft.github.io/graphrag/) इस समस्या के लिए माइक्रोसॉफ्ट अनुसंधान' समाधान है [ग्राफ-आरएजी कागज](https://arxiv.org/pdf/2404.16130) दो क्वेरी क़िस्मों को पहचाना कि आधारलाइन RAG गलत से संभालता है (**संवेदना** और **संयोजी**और उन्हें संबोधित करने के लिए एक विशेष सिस्टम बनाया

सिर्फ खंडों को अंतःस्थापित करने के बजाय **ज्ञान ग्राफ** जो इकाइयों और उनके संबंधों को पकड़ता है

## GraphRAG कैसे काम करता है

**एक नज़र पर पाइपलाइन**

- **सूचकांकन** Chunks → entities/relations
- **Query:** स्थानीय = टुकड़े | ग्राफ पड़ोस | | | विश्वव्यापी |= | समुदाय सारांश

ग्राफRAG पाइपलाइन में कई घटक जोड़ता है

1. **निष्कर्षण** (entities
2. **आलेख निर्माण** ज्ञान ग्राफ भंडारण
3. **सारांशीकरण** समुदाय पता लगाना

```mermaid
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: अस्तित्व निष्कर्षण

एक एलएलएम प्रत्येक टुकड़ा पढ़ता है और बाहर निकालता है **इकाइयां** विषयों पर चर्चा की जा रही है

```
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: ज्ञान ग्राफ निर्माण

सभी इकाइयां और संबंध एक ग्राफ बनाते हैं

```mermaid
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
```

### चरण 4: समुदाय पता लगाना | ( | लीडन एल्गोरिथ्म

 [लीडन एल्गोरिथ्म](https://arxiv.org/pdf/1810.08473.pdf) clusters densely connected nodes into communities. यह महत्वपूर्ण है क्योंकि यह आपको देता है *स्थिर* सारांश और प्राप्त करने के लिए क्लस्टर

- **समुदाय 1**आरंभिक स्टैक
- **समुदाय 2**:  "Container Infrastructure"
- **समुदाय 3**: "RAG पाइपलाइन" (ONNXM SK4 एम्बेडिंग्स

ध्यान दें कि कैसे Qdrant दो समुदायों में प्रकट होता है

### चरण 5: समुदाय सारांश

एक एलएलएम हर समुदाय के लिए प्रत्येक रैखिक स्तर पर सारांश उत्पन्न करता है

```
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."
```

## क्वेरी मोड

ग्राफ आर ए जी तीन क्वेरी मोड प्रदान करता है

### वैश्विक खोज

**के लिए सर्वोत्तम:** मुख्य विषय क्या हैं

समुदाय सारांश का उपयोग करता है (एकल टुकड़े नहीं करता है

```
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 को कैसे कॉन्फ़िगर करता हूँ

एंटीटीटी-परंपरागत भेक्टर खोज के साथ फोकसित ग्राफ ट्र्रांसल को संयोजित करता है

```
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
```

### ड्राइव खोज

**के लिए सर्वोत्तम:** "X Y से कैसे संबंध रखता है

ड्राइव खोज (लिएबल ट्रेवर्सिल के साथ गतिक तर्क और अंतर [जैसा कि GraphRAG डक में वर्णन किया गया है](https://microsoft.github.io/graphrag/query/drift_search/)स्थानीय खोज को सामुदायिक संदर्भ के साथ जोड़ता है

```
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."
```

# GraphRAG को हमारे वर्तमान प्रणाली के साथ तुलना

Let's map GraphRAG अवधारणाओं में क्या हम पहले से ही है `Mostlylucid.SemanticSearch`:

अवयव | चालू प्रणाली | | | GraphRAG समतुल्य
|-----------|---------------|---------------------|
| **सम्मिलित** | ONNX (allM SK2MiniLM-LMST4vMSC5 MSSK6 Same SSK7or OpenAIMS)
| **भेक्टर भंडार** Qdrant
| **इकाई निष्कर्षण** कोई भी नहीं
| **ज्ञान ग्राफ** % 1 ग्राफ डाटाबेस% 2 में% 3 स्मृति% 4
| **सामुदायिक खोज** लेडेन एल्गोरिथ्म
| **Query: विशिष्ट** | `SemanticSearchService.SearchAsync()` स्थानीय खोज
| **Query: Global** समर्थित नहीं है

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

```csharp
// 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);
}
```

# कार्यान्वयन दृष्टिकोण

एक मौजूदा प्रणाली में ग्रैफआरएग जोड़ने के तीन तरीके हैं

## विकल्प 1: पाइथोन साइडकायर | ( | खोज के लिए सिफारिशित |)

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

```yaml
# 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
```

```csharp
// 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;
    }
}
```

**Pros:** माइक्रोसॉफ्ट का उपयोग करें
**कन्स** पाइथोन निर्भरता, अनुक्रमण के लिए एलएलएम लागत

## विकल्प 2:

C#. में मुख्य घटकों का निर्माण BERT - आधारित निष्कर्षण और ओलमा पैटर्न से [डॉक-सममैरिजर](/blog/docsummarizer-tool) इसी तरह यहाँ काम करें

### इकाई निष्कर्षण

LLM को पहचानने के लिए पूछें *चीजें* प्रत्येक खंड में

```csharp
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);
}
```

**उत्पादन की आवश्यकता** LLM JSON आउटपुट *इजाज़त* टूटना. यह वैकल्पिक कठोरता नहीं है

- **योजना-सीमित उत्पादन** (Ollama's `format: json`, OpenAI
- **पुनः प्रयास करें-with-repair loops** विरूपित JSON पता लगाएं
- **फालबैक निष्कर्षण** सामान्य इकाई प्रकार के लिए regex पैटर्न

LLMs संभाव्यतावादी हैं; आपका निष्कर्षन पाइपलाइन नहीं होना चाहिए

### संबंध निष्कर्षण

एक बार जब आप इकाइयां है, तो LLM से पूछें कि वे कैसे जोड़ते हैं

```csharp
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));
}
```

### अस्तित्व सामान्यीकरण के साथ ग्राफ भंडारण

सबसे बड़ा व्यावहारिक दर्द है **इकाई उपनामकरण**एक ही नोड होना चाहिए

```csharp
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();
}
```

गंभीर उपयोग के लिए, सम्मिलन पर विचार करें-आधारित इकाई डेड्युप्लिकेशन एंटीटीटी2 यदि दो इकाई नामों में समान सम्मिलनों है

**उत्पादन पीड़ा बिन्दु** मूल्य ग्राफ गुणवत्ता पर निर्भर करता है

- **उपनाम/alias तालिका**: मानक नाम और ज्ञात उपनाम बनाए रखें
- **संबंध स्कीमा नियंत्रण**: अवरोध ने भ्रमित रिश्ता प्रकारों को रोकने के लिए पूर्वाग्रहों को अनुमति दी
- **विश्वसनीयता अंकन + pruning**: सभी निकाले गए संबंध समान रूप से विश्वसनीय नहीं हैं
- **वृद्धिशील पुनः--indexing**: जब दस्तावेज अद्यतन करते हैं

### ग्राफ ट्रेवर्सल

संबंधित इकाइयों की खोज एक चौड़ाई है

```csharp
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();
}
```

### सामुदायिक खोज

यह एक संयोजित components baseline है **नहीं** पूर्ण लीडन. लीडेन मॉड्यूलरिटी के लिए अनुकूलता करता है | ( | घने आंतरिक कनेक्शन |, | विरल बाहरी कनेक्टर | МSK3 | उचित कार्यान्वयन के लिये ग्राफ लाइब्रेरी का उपयोग करें या एल्गोरिथ्म को पोर्ट करें

```csharp
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;
}
```

### सामुदायिक सारांश

प्रत्येक समुदाय को अपने विषय का वर्णन करने वाला सारांश प्राप्त होता है

```csharp
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);
}
```

## विकल्प 3: हाइब्रिड (प्रैक्टिकल मध्य भूमि

यह सिफारिशित दृष्टिकोण है यदि आपके पास पहले से ही कार्यशील भेक्टर खोज है

### क्वेरी वर्गीकरण

पहले पता लगाएं कि यह प्रश्न किस प्रकार है

```csharp
// 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;
}
```

### स्थानीय खोज (Enhanced)

मौजूदा भेक्टर खोज का उपयोग करें

```csharp
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));
}
```

### वैश्विक खोज

मानचित्र-समूह सारांशों पर घटाएँ (नहीं भेक्टर खोज की जरूरत है

```csharp
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)));
}
```

### ड्राइव खोज (कनेक्टिव क्वेरी

के लिए स्थानीय परिणामों को सामुदायिक संदर्भ में जोड़ें "क्या X Y से संबंधित है

```csharp
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.");
}
```

# लागत और निष्पादन विचार

GraphRAG का शुद्ध भेक्टर RAG . के मुकाबले महत्वपूर्ण सौदे है

## सूचकांकन लागत

इकाई/संबंध निष्कर्षण लागत मॉडल के अनुसार महत्वपूर्ण रूप से भिन्न होते हैं। **एक या दो LLM कॉल प्रति खंड** और कम संख्या में सामुदायिक सारांशों के लिए कॉल

ऑपरेशन | वेक्टर RAG | ग्राफRAG |
|-----------|------------|----------|
| **सम्मिलित** | 1 कॉल
| **अस्तित्व/संबंध निष्कर्षण** कोई भी नहीं
| **सामुदायिक सारांश** कोई भी नहीं

blog posts with 5 chunks each

## क्वेरी लागत

Query Type
|------------|------------|----------------|-----------------|
| **भेक्टर खोज** कॉल
| **ग्राफ ट्रास्राकल** क्वेरी
| **एलएलएम कॉल्स** माप

वैश्विक खोज एक क्वेरी के लिए अधिक महंगा है, लेकिन यह प्रश्नों का जवाब देता है जो स्थानीय खोज सरलता से कर सकता है

## ग्राफ आर ए जी विफल मोड

GraphRAG के लिए ध्यान रखें

- **निष्कर्ष त्रुटि**: एलएलएम्स अस्तित्वों को छोड़ते हैं या भ्रमित संबंध
- **अस्तित्व उपनामकरण**: "ASP
- **ग्राफ ड्राइप**: जब Docs अद्यतन करें, ग्राफ अस्थिर हो सकता है
- **सामुदायिक सारांश अचल हो रहे हैं**: सारांश जब इकाइयां बदलती हैं तो donM SK1t auto-update

अस्तित्व सामान्यीकरण सबसे बड़ा व्यावहारिक पीड़ा है

- कैनोनिकल नाम + उपनाम
- केस-फोल्डिंग और पून्यूशन सामान्यीकरण
- वैकल्पिक रूप से embedding-based entity deduplication

# हमारे ब्लॉग खोज के साथ एकीकृत

यहाँ ग्राफRAG कैसे ब्लॉग को बढावा दे सकता है

## मौजूदा प्रवाह

```
User types in search → SemanticSearchService → Qdrant → Results
```

## संवर्धित प्रवाह

वर्गीकृत विभिन्न खोज रणनीतियों के लिए क्वेरी पथ करता है **वैश्विक क्वेरी** प्रवाह - नोट कि यह कभी भी वेक्टर भंडार को छू नहीं करता है

```mermaid
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..."
```

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

```mermaid
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..."
```

प्रमुख अंतर: वैश्विक क्वेरी समूह सारांश एकत्रित करता है (corpusMSC2level themesM SK3 जबकि स्थानीय क्वेries विशिष्ट टुकड़े प्राप्त करते हैं जो इकाई संबंधों से समृद्ध होते हैं

> **एक सरल विकल्प** ग्राफ आर ए जी अभी भी बहुत अधिक एक अनुसंधान उपकरण है। **BERT एम्बेडिंग + BM25 शब्दकुञ्जी मिलान** बेहतर काम करता है. यह क्या है [स्रोतग्राफ's कोडी](https://sourcegraph.com/blog/how-cody-understands-your-codebase) कोड आसूचना के लिए उपयोग करता है [डॉक-सममैरिजर](/blog/docsummarizer-part3) दस्तावेज़ संक्षेपण के लिए उपयोग करता है. पैटर्न *जमा करना*, नहीं *निर्णय*आप जटिलता के साथ 20% से लाभ प्राप्त करते हैं

## क्रियान्वयन स्केच

API सीधा है

```csharp
[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
    };
}
```

सदिश खोज और ग्राफ खोज एक-दूसरे को संपूरित करता है. के लिए सदियों का उपयोग करें।

# निष्कर्ष

GraphRAG RAG को " से एक्सटेंशन करता है, समान टुकड़े ढूंढने के लिए।

**क्या GraphRAG जोड़ता है:**

- अस्तित्व और संबंध निष्कर्षण
- ज्ञान ग्राफ निर्माण
- सामुदायिक पता लगाना और पदानुक्रमिक सारांश
- संवेदना पैदा करने वाले प्रश्नों के लिए वैश्विक खोज
- कनेक्शन तर्क के लिए खोजें

**इसे कब प्रयोग करना है**

- आपके पास महत्वपूर्ण दस्तावेज संग्रह है
- उपयोक्ता पूछते हैं "क्या विषयवस्तु है" प्रकार के प्रश्न
- आपकी सामग्री में स्पष्ट इकाइयां और संबंध हैं
- आप स्वचालित रूप से सतह कनेक्शन करना चाहते हैं

**क्रियान्वयन पथ**

1. सबसे पहले, पूछें: क्या आप वास्तव में इस की जरूरत है
2. यदि हाँ है तो मान को सत्यापित करने के लिए पाइथोन साइडकार के साथ प्रारूप
3. बनाना .NET native यदि लागत है
4. स्थानीय LLMs का उपयोग करें (Ollama) अनुक्रमण लागतों को नियंत्रित करने के लिए

## संसाधन

**GraphRAG आधिकारिक**

- [ग्राफ आर ए जी दस्तावेज़ीकरण](https://microsoft.github.io/graphrag/) माइक्रोसॉफ्ट के आधिकारिक डक
- [GraphRAG GitHub](https://github.com/microsoft/graphrag) - स्रोत कोड और उदाहरण
- [ग्राफ आर ए जी कागज](https://arxiv.org/pdf/2404.16130) - मूल अनुसंधान पत्र
- [लीडन एल्गोरिथम कागज](https://arxiv.org/pdf/1810.08473.pdf) - समुदाय खोज एल्गोरिथ्म

**रेग श्रृंखला**

- [भाग 1: RAG मूल और बुनियादी](/blog/rag-primer)
- [भाग 2: RAG वास्तुकला और आंतरिक](/blog/rag-architecture)
- [भाग 3: RAG व्यावहारिक में](/blog/rag-practical-applications)
- [भाग 4: ONNX और Qdrant के साथ सेमेटिक खोज](/blog/semantic-search-with-onnx-and-qdrant)
- [भाग 5: हाइब्रिड खोज](/blog/rag-hybrid-search-and-indexing)

**सरल वैकल्पिक (BERT**

- [DocSummarizer भाग 3](/blog/docsummarizer-part3) - ग्राफ ओवरहेड के बिना हाइब्रिड पुनःप्राप्ति
- [स्रोतग्राफ कोडी वास्तुकला](https://sourcegraph.com/blog/how-cody-understands-your-codebase) उत्पादन हाइब्रिड खोज