ध्यान दें: इस लेख में वेब सामग्री की बुनियादी जानकारी दी गयी है जो सबसे सरल तरीके से चलती हैं । दो- आयतन्जर - यह बनावट यहाँ दिखाई देती है लेकिन उत्पादन: BERTETEETCTing, DRF सुरक्षा के लिए सीधे, TRF सुरक्षा, वैध उल्लेख, और उचित कवरिंग ट्रैक।

जब आप चैट रूम से पूछना "इस लेख को पढ़ें और इसे सार दें" क्या होता है? यदि आप चाहते हैं कि एआई एक ब्राउज़र खोलने और पढ़ने की तरह है कि यह कैसे काम करता है नहीं है.

वे अपने कोड चयन पर कारण हैं.

यह लेख आपको दिखाता है कि कैसे सी.# में यह तैयार किया जा सकता है ।

टीएल; डीआर: अपने कोड लाने से साफ होता है . LLM केवल टुकड़ों को आप बाहर कर देते हैं. चयन बनावट के द्वारा नुकसान होता है कि दोनों प्रतिबन्धों और बनावटों दोनों है.

यह एक चुनौती है जो इस कार्य को बनाती है

यहाँ उस अन्तर्दृष्टि है कि आप इन सिस्टमों का निर्माण कैसे करते हैं:

चयन उत्पाद निर्णय है. यह भी जहां सबसे कम संभावनाएं आती हैं.

LLM आपके चयन की गुणवत्ता नीचे है. यह आप इसे नहीं दिखा सकते जानकारी प्राप्त कर सकते हैं. जब एक एजेंट "को जवाब मिल सकता है," समस्या लगभग कभी मॉडल - यह नहीं है कि अपने चयन तर्क गलत मूल रूप से चुना है. (यह वही सिद्धांत है जो पीछे है. (यह एक ही सिद्धांत है) क्यों मैं कर रहा हूँ तून की तरह फ्रेमवर्क से दूर - वे चयन तर्क आप डिबग करने की जरूरत है.

इसी कारण "डिस्किंग" चुपचाप रह जाता है. एजेंट पूरे भरोसे के साथ जवाब देते हैं कि यह क्या देखा पर. आप कभी नहीं जानते कि यह सही सामग्री याद आती है.

flowchart LR
    URL[Full Page] --> Select[Your Selection]
    Select --> LLM[LLM Sees This]
    LLM --> Answer[Answer]
    
    URL -.->|"50KB"| Select
    Select -.->|"2KB"| LLM
    
    Miss[Missed Content] -.->|"Never seen"| X[❌]
    
    style Select stroke:#e74c3c,stroke-width:3px
    style Miss stroke:#95a5a6,stroke-width:2px,stroke-dasharray: 5 5

उसके मुताबिक काम कीजिए ।

---

कोड से पहले डिजाइन लक्ष्य

कुछ लिखने से पहले, ये सीमाएँ हैं:

आतंकवाद पर रोक लगाना |------------|----------------| | कोई जेएस रेंडरिंग नहीं स्थैतिक एचटीएमएल सिर्फ (CPHAR_) | लॉगिंग चिन्ह IMTACK प्रति निवेदन (२- ४K टोकन एक विशेष रूप से) | स्रोत सीमा से उत्तर लॉएलएम को वेब ज्ञान की कमी नहीं करनी चाहिए | डिस्टिटमेंट चयन SIV उसी इनपुट भाग में एक ही भाग देता है (deg हक़ेबल) | ऑबॉबेबल बताओ तुमने क्या चुना, क्यों, और क्या आप फेंक दिया

यदि आप समझा नहीं सकते कि क्यों एक बार चुना गया था, आप डिबग असफल नहीं कर सकते.

---

पाइपलाइन

flowchart TB
    URL[URL] --> Fetch[1. Fetch]
    Fetch --> Clean[2. Clean]
    Clean --> Chunk[3. Chunk]
    Chunk --> Select[4. Select]
    Select --> LLM[LLM]
    LLM --> Answer[Answer]
    
    Fetch -.->|"57KB HTML"| Clean
    Clean -.->|"6KB text"| Chunk
    Chunk -.->|"5 chunks"| Select
    Select -.->|"2 chunks"| LLM
    
    style Select stroke:#e74c3c,stroke-width:3px
    style Clean stroke:#f39c12,stroke-width:3px

प्रत्येक कदम डेटा को कम करता है. जब तक कि वह दिखता है, आप के 57KB से कम हो गया है किसी भी प्रकार का 2KB पाठ हो सकता है. हर विभाजन नुकसान होता है. प्रत्येक कटौती जवाब को कम कर सकता है. यह वही तरीका है जो मैं उपयोग करता हूँ. बड़ा सीएसवी फ़ाइलों की ओर इशारा किया जा रहा है -LLM कारण, अपने कोड गणना और चयन.

---

चल रहा उदाहरण

इस लेख में हम एक यूआरएल इस्तेमाल करेंगे:

https://learn.microsoft.com/en-us/dotnet/core/whats-new/dotnet-10/overview

और बढ़ती हुई विशेषता के तीन सवाल:

1. "क्या नया है . WET 10 में?"
2. "क्या प्रदर्शन सुधार का उल्लेख किया जाता है?"
3. "वहाँ AOT के बारे में कुछ है?"

इससे पता चलता है कि सवाल पूछने के तरीके में और भी कई बातें शामिल हैं ।

---

सेटअप

# Install Ollama from https://ollama.ai
ollama pull llama3.2:3b

# NuGet packages
dotnet add package AngleSharp      # HTML parsing
dotnet add package OllamaSharp     # Ollama client (5.1.x)

ओललमा सुस्पष्ट नोट: संस्करण 5.x, में GenerateAsync लौटाता है IAsyncEnumerable<GenerateResponseStream?> - यह नदियाँ संकेतों के रूप में वे उत्पन्न कर रहे हैं. आप के साथ इकट्ठा await foreachउदाहरण परियोजना पिन 5.5. 5

---

स्टेप 1: प्राप्त

मानक HTTP, लेकिन इस विषय के विवरण के साथ:

public class WebFetcher : IDisposable
{
    private readonly HttpClient _http;
    
    public WebFetcher()
    {
        var handler = new HttpClientHandler
        {
            AllowAutoRedirect = true,
            MaxAutomaticRedirections = 5,  // Cap redirects
            AutomaticDecompression = DecompressionMethods.All
        };
        
        _http = new HttpClient(handler) { Timeout = TimeSpan.FromSeconds(30) };
        _http.DefaultRequestHeaders.Add("User-Agent", 
            "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36");
    }
    
    public async Task<string> FetchAsync(string url)
    {
        var response = await _http.GetAsync(url);
        
        // Bail if not HTML
        var contentType = response.Content.Headers.ContentType?.MediaType ?? "";
        if (!contentType.Contains("html") && !contentType.Contains("text"))
            throw new InvalidOperationException($"Not HTML: {contentType}");
        
        response.EnsureSuccessStatusCode();
        return await response.Content.ReadAsStringAsync();
    }
    
    public void Dispose() => _http.Dispose();
}

इस संभाल क्या है: फिल्टरिंग्स (अनुप्रयोग), संपीडन, समय- सारिणी, उपयोक्ता एजेंट, सामग्री- क़िस्म का वैधीकरण.

क्या नहीं है: जावास्क्रिप्ट रेंडरिंग, सत्यापन, दर कम, रोबॉट्स.

---

चरण 2: साफ

अधिकांश HTML में ध्वनि है. इसे साफ करें या खाका पर निशानियाँ खराब करें.

एक साधारण पृष्ठ:

57KB HTML → 6KB useful text (90% reduction)

कौशल

flowchart LR
    HTML[Raw HTML] --> Remove[Remove Noise]
    Remove --> Find[Find Main Content]
    Find --> Extract[Extract Text + Headings]
    Extract --> Normalize[Normalize]
    
    Remove -.->|"script, style, nav, ads"| Find
    Find -.->|"main, article, .content"| Extract
    
    style Remove stroke:#e74c3c,stroke-width:3px
    style Find stroke:#f39c12,stroke-width:3px

साफ - सफाई करना खतरनाक है

आम गलतियाँ:

• एग्रेसिव चयनक्स वैध सामग्री को हटाता है
• मुख्य सामग्री में असाधारण वर्ग नाम हैं (ए).article-body, .post-text)
• उत्तर पट्टी में है या कॉल आउट बॉक्स में

माइट्रिशन्स:

• शीर्षकों को स्पष्ट रूप से रखे रहें (ए)h1-h6)
• द्वारा मिटाएँ भूमिका और जाना जाता है कि फोड़े, चौड़े पैटर्न नहीं
• लॉग: निकाली गई तत्व पथ + पाठ लंबाई
• फालबैक: यदि मुख्य सामग्री संदेहजनक रूप से कम है, शरीर की कोशिश करें

public class HtmlCleaner
{
    private readonly HtmlParser _parser = new();
    
    // Known noise - remove these entirely
    private static readonly string[] NoiseElements = 
        { "script", "style", "nav", "footer", "aside", "iframe", "noscript" };
    
    // Boilerplate patterns - remove by role, not aggressive wildcards
    private static readonly string[] NoiseSelectors = 
    {
        "[role='navigation']", "[role='banner']", "[role='complementary']",
        "[class*='cookie']", "[class*='newsletter']", "[aria-hidden='true']"
    };
    
    // Where to find content - order matters (most specific first)
    private static readonly string[] ContentSelectors = 
        { "main", "article", "[role='main']", ".content", ".post-content" };
    
    public CleanResult Clean(string html)
    {
        var doc = _parser.ParseDocument(html);
        
        // Remove noise
        foreach (var tag in NoiseElements)
            foreach (var el in doc.QuerySelectorAll(tag).ToList())
                el.Remove();
        
        foreach (var selector in NoiseSelectors)
            foreach (var el in doc.QuerySelectorAll(selector).ToList())
                el.Remove();
        
        // Find main content
        IElement? main = null;
        string? matchedSelector = null;
        
        foreach (var selector in ContentSelectors)
        {
            main = doc.QuerySelector(selector);
            if (main != null) { matchedSelector = selector; break; }
        }
        
        // Fallback to body if main content is suspiciously short
        var text = main?.TextContent ?? "";
        if (text.Length < 500 && doc.Body != null)
        {
            main = doc.Body;
            matchedSelector = "body (fallback)";
            text = main.TextContent;
        }
        
        return new CleanResult
        {
            Text = NormalizeWhitespace(text),
            MatchedSelector = matchedSelector ?? "none",
            OriginalLength = html.Length
        };
    }
    
    private string NormalizeWhitespace(string text)
    {
        text = Regex.Replace(text, @"[ \t]+", " ");
        text = Regex.Replace(text, @"\n\s*\n+", "\n\n");
        return text.Trim();
    }
}

public record CleanResult(string Text, string MatchedSelector, int OriginalLength);

पढ़ने की क्षमता (स्लेटिंग अनुच्छेदों, पाठ घनत्व) एक पूरा खरगोश छेद है. अब, विशिष्ट रूप से आधारित दस्तावेजों तथा ब्लॉग्स के लिए काम करता है. नमूना परियोजना में यदि आपको इसकी आवश्यकता है.

---

कदम 3: कुंक

आपके पास 6B का शुद्ध पाठ है. क्यों न इसे सब कुछ भेजें?

• छोटे - छोटे जीव - जंतुओं की ज़रूरत: जब ज़रूरी जानकारी को बड़े संदर्भ में दफनाया जाता है तो उससे भी बदतर काम करता है
• खर्च: अधिक सबूत = ज्यादा पैसा और देर
• फोकस: अलग - अलग तरीके से इस्तेमाल करने से हर चीज़ की तुलना में बेहतर तर्क पैदा होता है

आप की उम्मीद से अधिक रणनीति मामले . मैं गहराई में इस कवर स्मारक उपस्थिति (G) - वही सिद्धांत लागू करते हैं कि आप वेब पृष्ठों या दस्तावेज़ों को फिर से बदल रहे हैं या नहीं.

गर्भ में पल रहे वाक्य कुएँ

यह प्रारंभ बिन्दु है न कि उत्पादन कोड:

public List<string> ChunkBySentence(string text, int maxTokens = 2000)
{
    var chunks = new List<string>();
    
    // WARNING: This breaks on abbreviations, decimals, URLs, code samples
    var sentences = text.Split(new[] { ". ", ".\n", "! ", "? " }, 
        StringSplitOptions.RemoveEmptyEntries);
    
    var current = new StringBuilder();
    var tokens = 0;
    
    foreach (var sentence in sentences)
    {
        var sentenceTokens = EstimateTokens(sentence);
        
        if (tokens + sentenceTokens > maxTokens && current.Length > 0)
        {
            chunks.Add(current.ToString().Trim());
            current.Clear();
            tokens = 0;
        }
        
        current.Append(sentence).Append(". ");
        tokens += sentenceTokens;
    }
    
    if (current.Length > 0)
        chunks.Add(current.ToString().Trim());
    
    return chunks;
}

// Rough estimate - OK for demos, not for billing
private int EstimateTokens(string text) 
    => (int)(text.Split(' ').Length * 1.3);

क्यों यह मूर्खतापूर्ण है:

• ". " "डी. स्मिथ" पर ब्रेक करें, "v0" यूआरएल, यूआरएल
• शब्द गणना द्वारा अनुमानित अनुमान '% 1' है
• फिर से कोशिशों के बीच कोई अलग नहीं (रंग सीमा पर संदर्भ)

बेहतर : शीर्षकिंग- बेसिंग

दस्तावेज़ों के लिए, खण्ड द्वारा फिर से लिखें:

public List<ContentChunk> ChunkByHeadings(string html)
{
    var doc = new HtmlParser().ParseDocument(html);
    var chunks = new List<ContentChunk>();
    
    var headings = doc.QuerySelectorAll("h1, h2, h3");
    
    foreach (var heading in headings)
    {
        var content = new StringBuilder();
        content.AppendLine(heading.TextContent);
        
        var sibling = heading.NextElementSibling;
        while (sibling != null && !sibling.TagName.StartsWith("H"))
        {
            content.AppendLine(sibling.TextContent);
            sibling = sibling.NextElementSibling;
        }
        
        chunks.Add(new ContentChunk
        {
            Heading = heading.TextContent.Trim(),
            Content = content.ToString().Trim(),
            HeadingLevel = int.Parse(heading.TagName[1..])
        });
    }
    
    return chunks;
}

यह दस्तावेज़ ढांचा बनाए रखता है तथा चयन को अधिक अर्थपूर्ण बनाता है.

---

चरण 4: चुनें

यह वह जगह है जहाँ बहुत से असफल हो जाएगा. तथा जहाँ डिबगिंग प्रारंभ होगा.

आपके पास 5 बार है. उपयोक्ता ने पूछा कि "क्या प्रदर्शन सुधार हैं . N.ET 10 में?" केवल 1 2 बार उल्लेख प्रदर्शन प्रदर्शन. उन पर भेजें.

flowchart TB
    Q["Question: What perf improvements?"] --> Score[Score Each Chunk]
    
    subgraph Chunks
        C1["Chunk 1: Overview..."] 
        C2["Chunk 2: Runtime perf..."]
        C3["Chunk 3: Libraries..."]
        C4["Chunk 4: SDK changes..."]
    end
    
    Score --> C1
    Score --> C2
    Score --> C3
    Score --> C4
    
    C2 -->|"score: 3"| Top[Selected]
    C3 -->|"score: 1"| Top
    
    style C2 stroke:#27ae60,stroke-width:3px
    style C1 stroke:#95a5a6,stroke-width:2px,stroke-dasharray: 5 5
    style C4 stroke:#95a5a6,stroke-width:2px,stroke-dasharray: 5 5

कीवर्ड मेल खाने योग्य (एमपीम्पल, डिबग)

public record ScoredChunk(string Content, string? Heading, int Score, List<string> MatchedKeywords);

public List<ScoredChunk> SelectByKeywords(
    List<ContentChunk> chunks, 
    string question, 
    int topK = 3)
{
    // Normalize and filter stopwords
    var keywords = question.ToLower()
        .Split(' ', StringSplitOptions.RemoveEmptyEntries)
        .Where(w => w.Length > 3)
        .Where(w => !Stopwords.Contains(w))
        .Select(w => w.Trim(',', '.', '?', '!'))
        .Distinct()
        .ToList();
    
    var scored = chunks.Select(chunk =>
    {
        var text = (chunk.Heading + " " + chunk.Content).ToLower();
        var matched = keywords.Where(kw => text.Contains(kw)).ToList();
        
        // Boost if keyword appears in heading
        var headingBoost = chunk.Heading != null && 
            keywords.Any(kw => chunk.Heading.ToLower().Contains(kw)) ? 2 : 0;
        
        return new ScoredChunk(
            chunk.Content, 
            chunk.Heading, 
            matched.Count + headingBoost,
            matched
        );
    })
    .OrderByDescending(x => x.Score)
    .Take(topK)
    .ToList();
    
    // LOG THIS - it's your debugging lifeline
    foreach (var s in scored)
        Console.WriteLine($"  [{s.Score}] {s.Heading ?? "(no heading)"}: {string.Join(", ", s.MatchedKeywords)}");
    
    return scored;
}

private static readonly HashSet<string> Stopwords = new()
    { "what", "how", "does", "the", "are", "is", "in", "for", "of", "to", "and" };

विभिन्न संख्याओं के ऊपर कुंजी सुधार:

• एनक्रिप्ट करना बन्द करें (अन्यथा "क्या" तथा " हमेशा मेल खाता")
• शीर्षक बढ़ता है (प्रयोगात्मक संकेत)
• लॉग किए गए बीजशब्द - यह आपकी डिबगिंग जीवनवाली है

एम्बेडिंग- बेसिड (एसएट्रिक)

की-वर्डस असफल हो गई है Synyyms. "ffff" नहीं होगा "संत्र सुधार".

एम्बेडिंग डिस्टिक समानता. यदि आप स्कैन और सदिश खोज पर गहरा जाना चाहते हैं, तो मैं इस व्यापक कवर पर कवर करता हूँ RAGErr श्रृंखला और ऑन एनएक्स के साथ उन्नत खोज.

public async Task<List<ScoredChunk>> SelectByEmbedding(
    List<ContentChunk> chunks, 
    string question, 
    int topK = 3)
{
    var questionEmbed = await EmbedAsync(question);
    
    // Cache these per URL in production
    var scored = new List<(ContentChunk Chunk, double Score)>();
    
    foreach (var chunk in chunks)
    {
        var chunkEmbed = await EmbedAsync(chunk.Content);
        var similarity = CosineSimilarity(questionEmbed, chunkEmbed);
        scored.Add((chunk, similarity));
    }
    
    return scored
        .OrderByDescending(x => x.Score)
        .Take(topK)
        .Select(x => new ScoredChunk(x.Chunk.Content, x.Chunk.Heading, (int)(x.Score * 100), new()))
        .ToList();
}

private async Task<double[]> EmbedAsync(string text)
{
    var request = new EmbedRequest { Model = "nomic-embed-text", Input = [text] };
    var response = await _ollama.EmbedAsync(request);
    return response.Embeddings.First().ToArray();
}

व्यापार- ऑफ:

• बीजशब्द: फास्ट, डिबगेबल, शाब्दिक मिलान
• एम्बेडिंग: CATAN, परंतु धीमी और कोडिंग की जरूरत है

उत्पादन के लिए, कैश एम्बेडिंग प्रति (URL, URLsh) या किसी सदिश डाटाबेस में स्केल्स.

---

कार्ड में भेज रहा है

स्रोत के भीतरी उत्तरों को बलपूर्वक व्यवस्थित करें:

public string BuildPrompt(string url, List<ScoredChunk> chunks, string question)
{
    var sb = new StringBuilder();
    
    sb.AppendLine("You are answering a question using ONLY the content below.");
    sb.AppendLine("Rules:");
    sb.AppendLine("- Answer ONLY from the provided sources");
    sb.AppendLine("- Cite which SOURCE number supports each claim");
    sb.AppendLine("- Include 1-2 brief quotes as evidence");
    sb.AppendLine("- If the answer isn't in the sources, say 'Not enough information'");
    sb.AppendLine("- End with Confidence: High/Medium/Low");
    sb.AppendLine();
    
    for (int i = 0; i < chunks.Count; i++)
    {
        sb.AppendLine($"=== SOURCE {i + 1} ===");
        if (chunks[i].Heading != null)
            sb.AppendLine($"Section: {chunks[i].Heading}");
        sb.AppendLine($"From: {url}");
        sb.AppendLine(chunks[i].Content);
        sb.AppendLine();
    }
    
    sb.AppendLine($"Question: {question}");
    sb.AppendLine();
    sb.AppendLine("Answer (with citations and confidence):");
    
    return sb.ToString();
}

यह "भारी सारांश" की ओर से "शिष्टता के साथ" की ओर ले जाता है।

ऑलमा को बुलाया जा रहा है

public async Task<string> AskAsync(string prompt)
{
    var request = new GenerateRequest { Model = "llama3.2:3b", Prompt = prompt };
    
    var response = new StringBuilder();
    await foreach (var chunk in _ollama.GenerateAsync(request))
    {
        if (chunk?.Response != null)
            response.Append(chunk.Response);
    }
    
    return response.ToString().Trim();
}

---

यह औजार उपयोग है

हमने क्या बनाया है एक एजेंट नमूना है बिना फ्रेमवर्क के. मैं पर बढ़ा क्यों मैं Lacagin से इस दृष्टिकोण पसंद करते हैं - स्पष्ट बम विस्फोट ने जादू को एक जादू कर दिया जब डिबगिंग मामलों में.

flowchart LR
    subgraph Tools["Tools (Deterministic)"]
        T1[fetch_url]
        T2[clean_html]
        T3[chunk_text]
        T4[select_relevant]
    end
    
    subgraph LLM["LLM (Reasoning)"]
        R[Interpret + Answer]
    end
    
    T1 --> T2 --> T3 --> T4 --> R
    
    R -->|"Low confidence"| Retry[Retry with different selection]
    Retry --> T4
    
    style T4 stroke:#e74c3c,stroke-width:3px
    style R stroke:#3498db,stroke-width:3px

लूप: यदि भरोसा कम है, तो अधिक रीप्लेस या भिन्न बीजशब्द के साथ फिर से कोशिश करें.

var answer = await AskAsync(prompt);

if (answer.Contains("Not enough information") || answer.Contains("Confidence: Low"))
{
    // Retry with more chunks
    var moreChunks = SelectByKeywords(allChunks, question, topK: 5);
    answer = await AskAsync(BuildPrompt(url, moreChunks, question));
}

---

क्या गलत जाता है

flowchart TB
    subgraph Failures["Failure Modes"]
        F1[Cleaner removes content]
        F2[Chunking breaks mid-thought]
        F3[Selection picks wrong chunks]
        F4[LLM hallucinates connections]
    end
    
    F1 --> R1["'Not enough info' - answer existed"]
    F2 --> R2["Partial answer - context lost"]
    F3 --> R3["Wrong answer - right content skipped"]
    F4 --> R4["Confident but wrong"]
    
    style F3 stroke:#e74c3c,stroke-width:3px

डिबगिंग नियम:

यदि उत्तर गलत है, तो यह लगभग हमेशा क्योंकि चयन गलत थानहीं, क्योंकि मॉडल असफल हो गया है.

डिबगिंग जांचसूची

1. लॉग चयनित आईडी तथा अंक
2. दिखाएँ कि कौन से बीजशब्द मेल खाते हैं (कांटिंग दूर)
3. सटीक प्राधिकृत करें भेजे गए थे
4. तुलना करें: क्या उठाया गया एचटीएमएल में सही सामग्री थी?

असफलता आमतौर पर LLM नहीं है. यह ऊपर की ओर है.

---

इसे एकसाथ रखना

public class WebAnalyzer : IDisposable
{
    private readonly WebFetcher _fetcher = new();
    private readonly HtmlCleaner _cleaner = new();
    private readonly OllamaApiClient _ollama = new(new Uri("http://localhost:11434"));
    
    public async Task<AnalysisResult> AnalyzeAsync(string url, string question)
    {
        // 1. Fetch
        var html = await _fetcher.FetchAsync(url);
        
        // 2. Clean (with observability)
        var cleaned = _cleaner.Clean(html);
        Console.WriteLine($"Cleaned: {cleaned.OriginalLength} → {cleaned.Text.Length} bytes ({cleaned.MatchedSelector})");
        
        // 3. Chunk
        var chunks = ChunkByHeadings(html);
        Console.WriteLine($"Chunks: {chunks.Count}");
        
        // 4. Select (with logging)
        Console.WriteLine("Selection scores:");
        var selected = SelectByKeywords(chunks, question, topK: 3);
        
        // 5. Prompt + LLM
        var prompt = BuildPrompt(url, selected, question);
        var answer = await AskAsync(prompt);
        
        return new AnalysisResult
        {
            Answer = answer,
            ChunksUsed = selected.Count,
            SelectionScores = selected.Select(s => s.Score).ToList()
        };
    }
    
    public void Dispose() => _fetcher.Dispose();
}

हमारे चल रहे उदाहरण के साथ उपयोग:

using var analyzer = new WebAnalyzer();

var result = await analyzer.AnalyzeAsync(
    "https://learn.microsoft.com/en-us/dotnet/core/whats-new/dotnet-10/overview",
    "What performance improvements are in .NET 10?"
);

Console.WriteLine(result.Answer);

आउटपुट में उल्लेख तथा भरोसे शामिल हैं:

Based on SOURCE 1 and SOURCE 2:

.NET 10 includes several performance improvements:
- JIT improvements including better inlining and method devirtualization (SOURCE 1)
- "Enhanced loop inversion for better optimization" (SOURCE 1)
- NativeAOT enhancements for improved code generation (SOURCE 2)

Confidence: High

---

जब यह कार्य करता है (और नहीं करता)

नेकी करता है अच्छे काम नहीं करता है |------------|--------------| प्रलेखन प्रलेखन जावास्क्रिप्ट व्याख्यानGenericName ब्लॉग पोस्ट, आलेख गतिशील/in nderviod तमाम तकनीकी संदर्भों जिब्रोला बहु-पेज खोजGenericName स्थैतिक एचटीएमएल जमने वाली विषयवस्तु यूनिडायरेक्शनल

जेएस-की साइटों के लिए, आप की आवश्यकता है .नेटटी के लिए खेलें.

---

मुख्य सिद्धांत

flowchart LR
    subgraph Your["Your Code's Job"]
        direction TB
        F[Fetch reliably]
        C[Clean carefully]
        S[Select correctly]
        O[Observe everything]
    end
    
    subgraph LLM["LLM's Job"]
        direction TB
        R[Reason over what you gave it]
        A[Admit when it doesn't know]
    end
    
    Your --> LLM
    
    style S stroke:#e74c3c,stroke-width:3px
    style R stroke:#3498db,stroke-width:3px

जो आपने दिया है उसके बारे में LLM केवल तर्क कर सकता है. चयन आपकी जिम्मेदारी है.

ब्राउज़ करने के लिए llm मत पूछो. इसे तर्क के लिए पूछें.

---

पूरा नमूना परियोजना

कार्यशील कार्यान्वयन पूर्ण करें: सबसे पुराना.Llmmer

शामिल करें:

• WebFetcher - एचटीटीपी उचित हैंडल के साथ
• HtmlCleaner - शोर हटाया जा रहा है + फ़ालबैक नीति.
• ContentChunker - वाक्य और शीर्षक- आधारित रिपरिंग
• WebContentAnalyzer - लॉगिंग के साथ पूरापुन
• OllamaExtensions - स्ट्रीमिंग प्रतिक्रिया के लिए मददगार

cd Mostlylucid.LlmWebFetcher
dotnet run

---

संसाधन

लाइब्रेरीज़

• कोण सुस्पष्ट - एचटीएमएल पारसिंग
• पहाड़ों को ठोस करता है - ओलमा क्लाएंट

LLM

• ओलमाjapan. kgm - स्थानीयLLM बंद
• Alllan3.2:3b - तेज, सक्षम मॉडल
• नोइमिक पाठ - एम्बेडिंग (0-22MBMB)

संबंधित आलेख

• दोरेक्टर सेवर्स - जादू - टोने के बारे में क्या कहा जा सकता है? वेब सामग्री के लिए. यह लेख लाने और विश्लेषण करने के लिए आसान तरीका दिखाता है; Docverzangers BERTEANECK, सत्यापित, और उचित विस्तार ट्रैक के साथ निर्माण - विशेष तरीका दिखाता है.
• स्थानीय इबराहीम के साथ बड़ा सीएसवी फ़ाइलों का विश्लेषण कर रहा है - एक ही पैटर्न:LM कारण, कोड गणना
• क्यों मैं लैंगाइन का उपयोग नहीं करते हैं - फ्रेमवर्क-रहित एजेंट डिजाइन
• RAGeser - पाने वाली पीढ़ी को समझना
• सेप्टिक खोज ऑन एनएनएक्स तथा क्यूडंट के साथ - स्थानीय खोज
• मूसा की कानून - व्यवस्था का पालन करना - पूरा रेजी कार्यान्वयन श्रृंखला

माइक्रोसाफ्ट स्टैक

• जेनिक कर्नेल - यदि आप फ्रेमवर्क चाहते हैं
• माइक्रोसॉफ़्ट.EAL. - डायजेस्ट