आपके RAG तंत्र में बहुत अच्छा है।

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

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

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

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

You can brute-force this with prompting and post

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

ग्राफ आर ए जी माइक्रोसॉफ्ट रिसर्च से आता है कागज और एक के रूप में उपलब्ध है open-source कार्यान्वयनयह विशिष्ट प्रश्नों के लिए भेक्टर खोज रखता है

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

भाग 1: GraphRAG मूलभूत इस अनुच्छेद
भाग 2: न्यूनतम व्यावहारिक ग्राफRAG

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

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

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

यदि आपके उपयोक्ता केवल विशिष्ट प्रश्न पूछते हैं अर्थिक खोज. GraphRAG चमकता है जब उपयोगकर्ताओं के लिए आवश्यक बड़ा चित्र0 और यह कि एमएसके1 विक्रेताओं की सिफारिश से कम श्रोता है

परिचय

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

भाग 1: मूल और बुनियादी - इतिहास
भाग 2: वास्तुकला और आंतरिक - तकनीकी गहरी डुबोई
भाग 3: RAG व्यावहारिक में - वास्तविक प्रणाली निर्माण
भाग 4a: ONNX & Qdrant कार्यान्वयन - सीपीयू
भाग 4b: क्रिया में सेमेटिक खोज - टाइपेहेड, हाइब्रिड खोज
भाग 5: हाइब्रिड खोज - उत्पादन एकीकरण
भाग 6: GraphRAG (इस अनुच्छेद के लिए ज्ञान ग्राफ्स

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

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

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

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

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

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

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

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

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

// 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 | लेकिन यह उन्हें समूह नहीं देता या यह बताता है कि वे कैसे जोड़ते हैं

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

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

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

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

ग्राफ आर ए जी इस समस्या के लिए माइक्रोसॉफ्ट अनुसंधान' समाधान है ग्राफ-आरएजी कागज दो क्वेरी क़िस्मों को पहचाना कि आधारलाइन RAG गलत से संभालता है (संवेदना और संयोजीऔर उन्हें संबोधित करने के लिए एक विशेष सिस्टम बनाया

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

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

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

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

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

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

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

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

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: समुदाय पता लगाना | ( | लीडन एल्गोरिथ्म

लीडन एल्गोरिथ्म 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 डक में वर्णन किया गया हैस्थानीय खोज को सामुदायिक संदर्भ के साथ जोड़ता है

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 जोड़ेगा वैश्विक खोज और ड्राइव खोज क्षमताएँ

// 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: पाइथोन साइडकायर | ( | खोज के लिए सिफारिशित |)

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

# 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;
    }
}

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

विकल्प 2:

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

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

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

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 से पूछें कि वे कैसे जोड़ते हैं

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

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

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

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: जब दस्तावेज अद्यतन करते हैं

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

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

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 | उचित कार्यान्वयन के लिये ग्राफ लाइब्रेरी का उपयोग करें या एल्गोरिथ्म को पोर्ट करें

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

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

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

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

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

// 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)

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

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

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

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

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

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

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

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

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

एक सरल विकल्प ग्राफ आर ए जी अभी भी बहुत अधिक एक अनुसंधान उपकरण है। BERT एम्बेडिंग + BM25 शब्दकुञ्जी मिलान बेहतर काम करता है. यह क्या है स्रोतग्राफ's कोडी कोड आसूचना के लिए उपयोग करता है डॉक-सममैरिजर दस्तावेज़ संक्षेपण के लिए उपयोग करता है. पैटर्न जमा करना, नहीं निर्णयआप जटिलता के साथ 20% से लाभ प्राप्त करते हैं

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

API सीधा है

[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 जोड़ता है:

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

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

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

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

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

संसाधन

GraphRAG आधिकारिक

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

रेग श्रृंखला

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

DocSummarizer भाग 3 - ग्राफ ओवरहेड के बिना हाइब्रिड पुनःप्राप्ति
स्रोतग्राफ कोडी वास्तुकला उत्पादन हाइब्रिड खोज

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

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

परिचय

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

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

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

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

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

चरण 1: अस्तित्व निष्कर्षण

चरण 2: संबंध निष्कर्षण

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

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

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

क्वेरी मोड

वैश्विक खोज

स्थानीय खोज

ड्राइव खोज

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

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

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

विकल्प 2:

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

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

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

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

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

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

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

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

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

वैश्विक खोज

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

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

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

क्वेरी लागत

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

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

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

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

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

निष्कर्ष

संसाधन