अगर आप RAG के लिए नया है RAG स्पष्ट किया गया और आरएजी वास्तुकला. यह पोस्ट उस बिंदु के लिए है जहां आप ' एक RAG पाइपलाइन बनाया है कि अधिकतर काम करता है, … , और अब आप के लिए यह लागत में भुगतान कर रहे हैं

यह क्या शामिल करता है उत्पादन के पीछे वास्तुकला संबंधी पैटर्न RAG. हाथ के लिएM SK1 कार्यान्वयन पर, देखें आरएजी के साथ एक दस्तावेज सारणी तैयार करना.

यह कहाँ से आता है मैंने बनाया डॉक-सममैरिजर दस्तावेज़ आरएजी इंजन डेटा-सममारीजरName डेटा RAG इंजन ImageSummarizerComment छवि RAG इंजन ऑडियोसममारीजरName (ऑडियो RAG इंजन सुस्पष्टRAG दस्तावेज़ Q

नोट: आप सही रूप से इस साइट पर सेमेटिक खोज टूटी है ध्यान दिया गया हो सकता है-और हाँ यह है, यह एक कॉन्फ़िगरेशन समस्या है मैं नहीं हूँ।

त्वरित आरएजी शब्दावली ताज़ा करने वाला

पुनःप्राप्ति-अग्रिम जेनरेशन (RAGM SK2 उन वाक्यांशों में से एक बन गया है जिसका अर्थ होता है सब कुछ और कुछ नहीं.

बहुत से टीमों के लिए RAG कर रहा है

1. Chunk दस्तावेज़
2. इनको सम्मिलित करें
3. ऊपर प्राप्त करें
4. सभी प्रॉ prompt में चिपकाएँ
5. मॉडल से पूछें कि “उस को कॉन्फ़िगर करें

यह काम करता है जब तक यह नहीं करता है

यह’ महंगा है, यह’ इस बारे में तर्क करने के लिए कठिन हैं, और यह चुपचाप मॉडल को उत्तरदायित्व सौंपता है। : संरचना का विश्लेषण करना, फिल्टरों पर बल देना, decide what matters, reconcile contradictions,

जब लोग कहते हैं, “RAG भ्रमित करता है, ” या “RAg अच्छी तरह से फ़िल्टर नहीं करता है

समस्या है समस्या है लचीला RAG.

यह पोस्ट एक भिन्न डिफ़ॉल्ट वर्णित करता है कम RAG - LLMs का उपयोग करें कम, नहीं अधिकM SK1 पहले से निर्धारक संकेतों को निकाल कर और मॉडलों के रूप में इलाज संश्लेषण इंजन, नहीं डेटा भंडार.

संदर्भ विंडो को भंडारण के समान व्यवहार करने में मुख्य त्रुटि

एक संदर्भ विंडो है

• अस्थिर
• नक़ल
• महंगा
• हर क्वेरी पर प्रतिदाय

यह डेटा भंडार नहीं है

जब आप “ बस प्रवर्धन में अधिक चिपकाएँ

• re-प्रणाली को हर बार व्याख्या करें
• उन्हें लागू करने के बजाय फ़िल्टर निकालें
• विवरण आप बाद में आवश्यक हो सकता है दूर सारांश
• जब यह गलत है तो भी विश्वासी होना चाहिए

यही कारण है कि RAG डेमो बहुत अच्छे लगते हैं और उत्पादन RAG प्रणालियां शांत रूप से खराब हो जाती हैं

क्या “Reduced RAG” का अर्थ है

कम RAG डिफ़ॉल्ट फ्लिप करता है

के बजाय

पाठ पुनः प्राप्त करें और मॉडल को यह तय करने दें कि क्या महत्वपूर्ण है

आप कर रहे हैं

एक बार यह तय करें कि क्या महत्वपूर्ण है , इसे भंडारित करें, और केवल जब आप संश्लेषण की जरूरत है तो मॉडल शामिल

व्यवहार में इसका मतलब है deterministic ingestion, cheap retrieval, bounded generation.

यदि यह परिचित लग रहा है, तो यह अवरोधित अस्पष्टता: probabilistic घटकों को छोड़ दें प्रस्तावित करना; निर्णायक प्रणालियों को छोड़ें निर्णय लेना.

पारंपरिक RAG vs Reduced RAG

सबसे पहले-,-मुझे यह दिखाना चाहिए कि अधिकांश टीमें क्या करते हैं और यह क्यों होता है

flowchart LR
    subgraph Traditional["❌ Traditional RAG: Everything Through the LLM"]
        T1[Documents] --> T2[Chunk Everything]
        T2 --> T3["Embed All Chunks<br/>(once)"]
        T3 --> T4[Vector Search]
        T4 --> T5["Paste Top-K<br/>(per query)"]
        T5 --> T6["LLM Decides<br/>(per query)"]
        T6 --> T7[Answer]
    end

    style Traditional stroke:#ef4444,stroke-width:3px
    style T6 stroke:#ef4444,stroke-width:3px
    style T5 stroke:#ef4444,stroke-width:2px

समस्याएँ

• LLM re-प्रणाली प्रत्येक क्वेरी को व्याख्या करता है
• फ़िल्टरों को लागू नहीं कर सकता है
• क्वेरी के साथ टोकन लागत स्केल
• जब मॉडल फिल्टर का आविष्कार करता है तो भ्रम

अब यहाँ कम RAG दृष्टिकोण है

flowchart TB
    subgraph Ingestion["✅ Ingestion (Once - Pay Upfront)"]
        I1[Source Docs] --> I2[Parse Structure]
        I2 --> I3["Extract Signals<br/>(deterministic)"]
        I3 --> I4[(Structured Fields)]
        I2 --> I5[Semantic Units]
        I5 --> I6[(Vector Store)]
        I2 --> I7[(Evidence Store)]
    end

    subgraph Query["Query Time (Cheap Per Query)"]
        Q1[User Question] --> Q2{Extract Filters}
        Q2 --> Q3["Filter Database<br/>(no LLM)"]
        Q2 --> Q4["BM25 Search<br/>(no LLM)"]
        Q2 --> Q5["Vector Search<br/>(no LLM)"]

        Q3 --> R[Candidate Set]
        Q4 --> R
        Q5 --> R

        R --> S["Small Evidence Pack<br/>(5 sources not 50)"]
    end

    subgraph Generation["LLM (Bounded Synthesis Per Query)"]
        S --> L[Synthesize Answer]
        L --> A[Answer + Citations]
    end

    style Ingestion stroke:#22c55e,stroke-width:3px
    style Query stroke:#3b82f6,stroke-width:3px
    style Generation stroke:#f59e0b,stroke-width:2px
    style I3 stroke:#22c55e,stroke-width:3px
    style Q3 stroke:#3b82f6,stroke-width:3px
    style L stroke:#f59e0b,stroke-width:3px

प्रमुख अंतर

चरण 1: निर्णायक इंजेक्शन | ( | नीरस बिट जो महत्वपूर्ण है

इंजेक्शन समय पर क्या आप कर सकते हैं बिना एक LLM.

उदाहरण: समर्थन टिकट प्रणाली

सिर्फ टिकट को पाठ में टुकड़े-टुकड़े करने के बजाय

Traditional: "Ticket #1234: Customer complained about slow loading..."
→ Embed entire text
→ Hope the LLM figures out it's about performance

अग्रभाग से संकेत निकालें

// Parse once during ingestion
var ticket = new SupportTicket
{
    Id = "1234",
    CreatedDate = DateTime.Parse("2025-01-15"),
    Category = "Performance",              // ← Deterministic field
    Product = "WebApp",                     // ← Filterable
    Priority = "High",                      // ← Sortable
    Customer = "Enterprise",                // ← Segment filter
    SentimentScore = -0.3,                  // ← Computed once
    Tags = ["slow-loading", "timeout"],     // ← Searchable
    Text = "Customer complained about..."   // ← Still keep for RAG
};

क्या आप निर्णायक रूप से बाहर निकाल सकते हैं

इसे एक बार करें

RAG का हार्ड भाग मॉडल नहीं है ' यह ' मॉडल से पहले सब कुछ है ठोस क्रियान्वयन के लिए आरएजी के साथ एक दस्तावेज सारणी तैयार करना और DocSummarizer: Building RAG Pipelines.

चरण 2: संकेतों को भंडारित करें

सही के एकक के रूप में व्यवहार करने के बजाय "chunks" भंडारित संरचनात्मक क्षेत्रों को धारण करता है

पाठ अभी भी सिस्टम - का हिस्सा है लेकिन यह बन जाता है प्रमाणक्या भी हम prompt में टाँसने के लिए हुआ है

यह भिन्नता है "RAG जवाब वीब हैं

लेकिन मैं कैसे पता क्या संकेत निकालने के लिए

आप नहीं कर सकते

कि' भंडारण का पूरा बिंदु है कच्चे संकेत LLM के बजाय

पारंपरिक RAG (परिवर्तित करने के लिए महंगा

// ❌ You asked the LLM to "summarize the key points"
var summary = await llm.Summarize(ticket.Text); // Expensive
await db.SaveAsync(summary); // Threw away the original structure

// Later: "Actually, we need sentiment scores too"
// 😱 Have to re-process 10,000 tickets through LLM again!

कम RAG (परिवर्तित करने के लिए सस्ते):

// ✅ Store raw signals extracted deterministically
var signals = new TicketSignals
{
    Text = ticket.Text,                    // ← Keep original
    WordCount = ticket.Text.Split().Length, // ← Cheap to compute
    ContainsErrorCode = Regex.IsMatch(ticket.Text, @"ERR-\d+"),
    MentionedProducts = ExtractProducts(ticket.Text), // ← Heuristic
    SentimentWords = CountSentimentWords(ticket.Text), // ← Word lists
    CreatedHour = ticket.Created.Hour      // ← Maybe useful later?
};

// Later: "We need to prioritize by sentiment"
// ✅ Just add a computed column - no LLM re-run needed!
await db.ExecuteSqlAsync(@"
    ALTER TABLE Tickets ADD COLUMN SentimentScore AS
    (SentimentWords->>'positive' - SentimentWords->>'negative')
");

अभी क्या हुआ

• आप भंडारित आप की जरूरत से अधिक संकेत (
• जब आवश्यकताओं में परिवर्तन हो गया भंडारित संकेतों से पुनः गणना मुक्त
• आपने LLM निष्कर्ष को 10,000 दस्तावेजों पर नहीं चलाया।

यह उसी पैटर्न है जैसे :

• डायरेक्टेड सिंथेटिक एवोल्यूशन परीक्षण परिणामों को भंडारित करता है।
• बोट खोज अनुरोध पैटर्नों को भंडारित करता है।

नियम अच्छी तरह याद रखें पहले अपने "memory को अद्यतन करें

प्रमुख वास्तुकला लाभ चूंकि आप अंतःकरणों के साथ निर्णायक संकेतों को भंडारित करते हैं (उनके स्थान पर नहीं),प्रणाली का प्रत्येक भाग स्वतंत्र रूप से बदल सकता है।

बहुल -वेक्टर भंडारों के साथ |( |Qdrant की तरह), |आप यहां तक कि जोड़ सकते हैं एक दस्तावेज पर कई एम्बेडिंग्स. एक नया एम्बेडिंग मॉडल का प्रयास करना चाहते हैं।

प्रत्येक घटक पूर्ण पाइपलाइन को पुनः निर्माण करने के लिए बाध्य किए बिना विकसित हो सकता है - और अन्यों को विकृत करने के बिना

क्या संकेत आप भंडारित करें

कुछ भी भंडारित करें जिसे आप संगणन कर सकते हैं सस्ती और निर्णायक ढंग-से.

महत्वपूर्ण संकेत सिर्फ हैं छोटा पाठ स्ट्रिंग—Not Giant Data Structures. YouM SK2re storing "PerformanceMSC4 CSK5 charsMST6 not "Customer complained about slow loading timesMSP8 | | (50+ words |

public class DocumentSignals
{
    // Always extract (almost free)
    public int CharCount { get; set; }              // Example: 1247
    public int WordCount { get; set; }              // Example: 203
    public int ParagraphCount { get; set; }         // Example: 5
    public string[] UniqueWords { get; set; }       // Example: ["timeout", "error", "api"]

    // Structural (parse once)
    public bool HasCodeBlocks { get; set; }         // true/false
    public bool HasLinks { get; set; }              // true/false
    public int HeadingCount { get; set; }           // Example: 3

    // Heuristic (simple patterns)
    public string[] MentionedProducts { get; set; }       // Example: ["WebApp", "API"]
    public string[] ErrorCodes { get; set; }              // Example: ["ERR-404", "ERR-500"]
    public Dictionary<string, int> SentimentWords { get; set; } // { "positive": 3, "negative": 7 }

    // Metadata (already available)
    public DateTime Created { get; set; }           // Example: 2025-01-15T14:23:00
    public string Author { get; set; }              // Example: "[email protected]"
    public string Category { get; set; }            // Example: "Performance" (not essay-length)

    // Computed (cheap math)
    public double ReadingTimeMinutes { get; set; }  // Example: 4.2
    public double KeywordDensity { get; set; }      // Example: 0.034
}

भंडारण लागत तुलना

संकेत हैं 10x छोटा से अधिक text, 4x छोटा LLM सारांशों से अधिक, और अनन्त सस्ती पुनः गणना करने के लिए (क्योंकि आप नहीं कर रहे हैं

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

यही कारण है कि आप एक बार भंडारण में पैसे देते हैं।

चरण 3: LLM के बिना खोजें

अधिकतर "RAG क्वेरी

• केवल नवीनतमdocs
• केवल यूके ग्राहकों के लिए "
• केवल वेतन योजना
• सिर्फ पिछले सप्ताह से त्रुटि

पारंपरिक RAG (expensiveM SK1unreliable):

// ❌ Paste everything into prompt and hope
var chunks = await vectorSearch.SearchAsync(query, k: 50); // 50 chunks!
var prompt = $@"
Given these 50 chunks of text, answer the question but ONLY use
docs from last week and ONLY for UK customers.

Chunks: {string.Join("\n", chunks)}

Question: {userQuestion}
";
var answer = await llm.GenerateAsync(prompt); // Expensive + unreliable

कम RAG (

// ✅ Filter first, retrieve less, synthesize last
var candidates = await db.Tickets
    .Where(t => t.CreatedDate > DateTime.Now.AddDays(-7))  // ← Database does this
    .Where(t => t.Region == "UK")                          // ← Not the LLM!
    .ToListAsync();

// Hybrid search on the filtered set
// (In production: push BM25 to database/index, not in-memory LINQ)
var bm25Results = candidates.Where(c => c.Text.Contains(keyword));
var vectorResults = await vectorSearch.SearchAsync(query, k: 5, filter: candidates);

// Small evidence pack
var evidence = RRF.Merge(bm25Results, vectorResults).Take(5);

// LLM only synthesizes
var answer = await llm.GenerateAsync($@"
Synthesize an answer using ONLY these 5 sources:
{FormatEvidence(evidence)}

Question: {userQuestion}
");

अभी क्या हुआ

• डाटाबेस निर्धारित रूप से फ़िल्टर किया गया (LLM नहीं है
• LLM को 5 स्रोतों के स्थान पर |50 | | (90% | टोकन ह्रास दिखाता है
• फिल्टर की गारंटी है

इसीलिए हाइब्रिड खोज उत्पादन में महत्वपूर्ण है हाइब्रिड खोज & स्वचालित पूरे RAG श्रृंखला के सबसे व्यावहारिक टुकड़ा है

वैकल्पिक: अभिप्राय को निकालने के लिए एलएलएम का उपयोग करना

अगर एक क्वेरी वास्तव में गडबड है शक़्ति उद्देश्य निकालने के लिए एक छोटा मॉडल का उपयोग करें

// Use small model to propose filters (ephemeral - discarded after use)
var intent = await smallModel.ExtractIntent(userQuestion);
// Returns: { intent: "troubleshoot", filters: { priority: "high", product: "api" } }

// Validate the proposal against known fields (deterministic)
var validatedFilters = ValidateAgainstSchema(intent.filters);

// Use validated filters for retrieval
var results = await db.Tickets.Where(validatedFilters).ToListAsync();

कोर सिद्धांत: एलएलएम प्रस्तावित करता है

यह आधार है अवरोधित अस्पष्टता पैटर्न

दीर्घकालिक निष्पादन पैटर्न में एक गहरी खोज के लिए जहाँ आप उनके आउटपुटों को जारी रखने के बिना अस्थायी रूप से LLMs का उपयोग करते हैं आग और Don't Quite Forget.

चरण 4: LLMs को संश्लेषण इंजनों के रूप में

पुनःप्राप्ति के बाद ही आप LLM को बुलाते हैं।

मॉडल संश्लेषित करेंनहीं बाध्यताओं को लागू करना, निर्णय सत्य, आविष्कार संरचना.

अगर आप के बारे में “LLMs उत्तर में पूरी संदर्भ विंडो को खींचने की चिंता करते हैं प्रतिबंधित अस्पष्ट संदर्भ खींचनायह क्या तुमने उससे करने के लिए कहा है

यह क्यों अधिक सुरक्षित है और सस्ता

लागत तुलना (प्रदर्शात्मक उदाहरण

एक विशिष्ट ग्राहक समर्थन RAG प्रणाली के लिए ऊँचाई तुलना

परिदृश्य प्रति दिन 10,000 समर्थन टिकट

गुरुत्व क्रम: ~10x प्रतिदिन लागत कटौती

और बेहतर अच्छे साक्ष्य और निर्णायक फिल्टरिंग के साथ-साथ आपको संभवतः कोई सीमा मॉडल की जरूरत नहीं है।

प्लस: त्रुटिमोचन समय कम करता है, कम समर्थन स्काल्सन होता है , और मॉडल लचीलापन M SK3 वास्तुकला परिवर्तनों के बिना स्वाप मॉडल

विश्वासनीयता

पारंपरिक RAG आधार पर फिल्टरिंग

// ❌ Prompt says "only UK customers" but model can ignore it
var answer = await llm.Generate(prompt); // No guarantee

कम RAG (प्रबल फिल्टरिंग

// ✅ Database physically prevents non-UK results
var results = db.Tickets.Where(t => t.Region == "UK"); // Guaranteed

क्यों यह अधिक सुरक्षित है फ़िल्टरों को पीढ़ी से पहले लागू किया जाता है।

स्पष्टीकरण

पारंपरिक RAG मॉडल ने यह कहा था, लेकिन मैं नहीं पता क्यों या किस टुकड़े से यह आया है

कम RAG:

// You know exactly why each result matched
var result = new SearchResult
{
    Text = "Server timeout error",
    MatchedBecause = new[]
    {
        "Region = UK (database filter)",
        "Created in last 7 days (date filter)",
        "BM25 score: 4.2 (keyword 'timeout')",
        "Vector similarity: 0.89 (semantic match)"
    },
    SourceChunks = [chunk1, chunk2], // ← Audit trail
    ConfidenceScore = 0.89
};

LLM संश्लेषण से पहले के उम्मीदवार सेट का परीक्षण करके आप यह जांच कर सकते हैं कि प्रत्येक परिणाम का मिलान क्यों है।

आरंभ करना: पारंपरिक रिफाक्टरिंग → कम RAG

अगर आप के पास पहले से ही एक काम कर रही RAG तंत्र है

चरण 1: अपने इंजेक्शन में संगठित क्षेत्र जोड़ें

से पहले

public class Document
{
    public string Id { get; set; }
    public string Text { get; set; }           // ← Only unstructured text
    public float[] Embedding { get; set; }
}

के बाद

public class Document
{
    public string Id { get; set; }
    public string Text { get; set; }           // ← Keep for evidence
    public float[] Embedding { get; set; }

    // Add deterministic signals (extract once during ingestion)
    public DateTime CreatedDate { get; set; }  // ← Parse from metadata
    public string Category { get; set; }       // ← Extract from filename/tags
    public string Author { get; set; }         // ← From file properties
    public string[] Tags { get; set; }         // ← Parse from content/metadata
    public double QualityScore { get; set; }   // ← Compute heuristics
}

चरण 2: फ़िल्टर को प्रवर्धनों से बाहर खिसकाएँ

से पहले

var prompt = "Only use docs from last month for product 'API'. Query: " + userQuery;
var chunks = await vectorStore.Search(userQuery, k: 50);
var answer = await llm.Generate(prompt + chunks); // ❌ LLM might ignore filters

के बाद

// ✅ Database enforces filters
var candidates = await db.Documents
    .Where(d => d.CreatedDate > DateTime.Now.AddMonths(-1))
    .Where(d => d.Category == "API")
    .ToListAsync();

// Search only the filtered candidates
var results = await vectorStore.Search(userQuery, k: 5, filter: candidates.Select(c => c.Id));
var answer = await llm.Generate(FormatEvidence(results)); // Much smaller context

चरण 3: हाइब्रिड खोज जोड़ें

// Combine keyword and semantic search
var keywordResults = await db.Documents
    .Where(d => EF.Functions.ToTsVector("english", d.Text)
        .Matches(EF.Functions.ToTsQuery("english", keywords)))
    .ToListAsync();

var vectorResults = await vectorStore.Search(userQuery, k: 20);

// Merge using Reciprocal Rank Fusion (RRF)
var merged = RRF.Merge(keywordResults, vectorResults, k: 5);

देखें हाइब्रिड खोज & स्वचालित पूर्ण कार्यान्वयन के लिए

चरण 4: अंतर मापें

इन मापनों को पहले और बाद में ट्रैक करें

public class RAGMetrics
{
    public int PromptTokens { get; set; }           // Should drop by 80-90%
    public int CandidatesRetrieved { get; set; }    // Should drop from 50+ to 5-10
    public TimeSpan QueryLatency { get; set; }      // Should improve
    public bool FiltersEnforced { get; set; }       // Should be true
    public List<string> EvidenceSources { get; set; } // Should be traceable
}

अंगूठी नियम

यदि आपका तंत्र हमेशा पर निर्भर करता है

पैटर्न कार्ड

सारांश: Reduced RAG मानसिक मॉडल

घटा RAG anti-' नहीं है।

इस तरह सोचें

Traditional RAG = "LLM, here's 50 chunks. Figure out what matters and answer."
Reduced RAG    = "Database, filter to 100. BM25, find keywords. Vector, find similar.
                  Now LLM, here are the 5 most relevant sources. Synthesize an answer."

शिफ्ट

• से: के रूप में LLM (सब कुछ करता है
• के लिए संश्लेषण इंजन के रूप में एलएलएम

आदिम

1. संकेत (deterministicM SK1 - dates, categoriesMSC4 scores, filters
2. प्रमाण क्या आप LLM को दिखाते हैं
3. प्रतिबंध (boundariesM SK1 - token budgetsMSC3 filter validation, citation requirements

पैटर्न

• एक बार संकेत निकालें
• निर्णायक रूप से फ़िल्टर करें (डेटाबेस इस पर अच्छे हैं
• खोज हाइब्रिड (BMM SK1 + भेक्टर
• संश्लेषण सीमाबद्ध (छोटे साक्ष्य पैकेज | → | LLM

यह क्या होता है जब आप सामान्य सॉफ्टवेयर इंजीनियरिंग अनुशासन को उन प्रणालियों के लिए लागू करते हैं जो भाषा मॉडल शामिल होते हैं

अगले कदम

अगर आप इस को बनाने के लिए तैयार हैं

1. सरल प्रारंभ करें एक संरचनात्मक क्षेत्र (CreatedDate) और एक डाटाबेस फ़िल्टर जोड़ें
2. पहले मापें ट्रैक टोकन गिनती पहले
3. हाइब्रिड खोज जोड़ें आरआरएफ के साथ बीएमएसके0 एमएसके1 भेक्टर लागू करेंमार्गदर्शक यहाँ)
4. धीरे-धीरे निर्माण करें Don'\t सब कुछ एक ही समय पर पुनरावलोकन करें

संदर्भ क्रियान्वयन

• DoomSummarizer: गहन अनुसंधान - व्यावहारिक रूप में कम आरएजी आरएग | : | \ 6- | सिग्नल आरआरएफ संश्लेषण |, | इकाई प्रोफाइल | МSK4 | सेमेटिक ग्राफ खोज | एमएसके5 | और समांतर लम्बी |एमएसके6 | रूप संश्लिष्ट | मएसके7 | सभी एकल द्विआधारी से
• आरएजी के साथ एक दस्तावेज सारणी तैयार करना - व्यावहारिक कार्यान्वयन की शुरुआत
• DocSummarizer RAG पाइपलाइन - पूर्ण इंजेक्शन पाइपलाइन
• ऑडियोसममारीजरName - स्पीकर डायराइजेशन के साथ ऑडियो फ़ोरेंसिक कैरेक्ट्रीज़ेशन
• सुस्पष्टRAG - हाइब्रिड खोज के साथ पूरा वेब एप्लिकेशन
• स्टिलियोफ्लो: सिग्नल-प्रवाहित कार्यप्रवाह conditional निष्पादन और escalation के साथ बहु-स्तर RAG पाइपलाइनों के लिए - orchestration इंजन
• अवरोधित अस्पष्टता - मूल संरचना

अवसंरचना पहले से ही वहाँ है