Wenn Sie brandneu zu RAG-, beginnen mit RAG erklärt und RAG-ArchitekturDieser Beitrag ist für den Punkt, an dem du eine RAG-Pipeline gebaut hast, meist works-… und jetzt Sie zahlen für es in Kosten -, fragility-, , und warum hat es beantwortet, dass die ?" , Debugging-Sitzungen -.

Was dies umfasst Das architektonische Muster hinter der Produktion RAG.MSK.0. Für die Hand, MSK.1.on-Implementierung siehe Aufbau eines Dokument-Zusammenfassung mit RAG.

Wo sie herkommt Ich habe gebaut DocSummarizer Dokumente RAG-Motoren ), DatenZusammenfassung Daten der RAG-Motoren ImageSummarizer Bild RAG-Motor AudioSummarizer Audio RAG-Motoren und LucidRAG Das gleiche Muster zeichnete sich über Dokumente hinweg aus.,, data, ,, Bilder, und Audio-.

HINWEIS:-Sie können zu Recht bemerkt haben, die semantische Suche auf dieser Website ist gebrochen... und yeah it.

Schnelle RAG Terminologieauffrischung

Retrieval---Augmented Generation ist zu einem jener Phrasen geworden, die bedeuten, alles und nichts.

Für eine Menge von Teams ist jetzt

1. Dokumente von Chunk
2. Einbetten
3. Nach oben abrufen
4. Alles in die Eingabeaufforderung einfügen
5. Bitten Sie das Modell, es auszustellen.

Es funktioniert... Bis es nicht mehr ’-t-.

Es ist teuer ,, es ist schwer zu denken über,, und es gibt ruhig Verantwortung zum Modell messk4, parse die Struktur, die Filter, ,, entscheiden, was zählt.,, versöhnt Widersprüche und seien Sie zuversichtlich darüber

Wenn Leute sagen, dass “RAG halluzinates” oder “RAG doesn't Filter gut ”, sie sind in der Regel verantwortlich für die falsche Komponente

Das Problem ist: Das Problem ist, faule RAG.

Dieser Beitrag beschreibt eine andere Standardeinstellung. Reduzierte RAG Verwendung von LLMs wenigerNicht mehr als ,, indem deterministische Signale nach vorne extrahiert werden und Modelle wie SynthesemotorenNicht Datenspeicher.

Der Kernfehler der Behandlung von Kontextfenstern wie Speicher

Ein Kontextfenster ist:

• vorübergehend
• nicht typisiert
• teuer
• bei jeder Abfrage zurückgezahlt

Es ist kein Datastore.

Wenn Sie gerade mehr in der Eingabeaufforderung stecken, fragen Sie ’, das Modell zu bitten,:

• jedes Mal die Struktur der Re---Parse
• Filter ableiten, anstatt sie durchzusetzen
• Zusammenfassung weg Details, die Sie später benötigen könnten
• selbst dann sicher klingen, wenn es nicht stimmt

Das ist, warum RAG-Demos sehen toll aus und Produktion RAG Systeme leise rot

Was bedeutet Reduzierter RAG?”

Reduzierte RAG kippt die Standardeinstellung

Anstelle von„:"

Erhalten Sie Text und lassen Sie das Modell entscheiden, was zählt

Du machst es mit :

Entscheiden Sie, was zählt, sobald es gespeichert wird., und nur das Modell einschließen, wenn Sie synthetisieren müssen.

In der Praxis bedeutet das: deterministische Aufnahme – billige Retrieval-Erzeugung – limitierte Generation.

Wenn sich das vertraut anhört, dann ist es die gleiche Systemform wie Beschränkte Fuzziness: let probabilistische Komponenten vorschlagenDeterministische Systeme lassen entscheiden.

Traditionelle RAG vs Reduzierte RAG

Erste let-'s sehen, was die meisten Teams tun und warum es teure messk3s

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

Probleme

• LLM stellt jede Abfrage in die Struktur
• Kann ' , Filter durchsetzen Nur " , stellen Sie schön , " , über prompt ,) ,
• Token-Kostenskala mit Abfragen
• Halluzinationen, wenn Modell Filter erfindet

Hier ist jetzt der Reduzierte RAG-Ansatz.

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

Wesentliche Unterschiede

Phase - Traditionelle RAG - Reduzierte RAG-Phase |-------|----------------|-------------| | Einnahme Nur Brocken und Einbetten von |.Extraktdaten ,. Kategorien ,. Entitäten ,. Qualitätsflaggen |. | Filtern Bitten Sie LLM, in der prompten Datenbank zu filtern. | Suchen Nur Vektoren von |BM25B+Vektor strukturierte Filter | Rolle des LLM PARSE-,-Filter ,- UND Antwort |-Synthetisieren Sie einfach die Antwort | Kosten Jede Abfrage zahlt sich für den vollen Kontext aus.

Schritt: Deterministische Einnahme des langweiligen Bits, das zählt

Bei der Einnahmezeit – ,- parse, was Sie können ohne ein LLM-.-

Beispiel: Unterstützung des Ticket-Systems

Statt nur Karten in Text zu würfeln

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

Signale nach oben extrahieren

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

Was Sie deterministisch extrahieren können

Signaltyp: Beispiele, warum es wichtig ist |-------------|----------|----------------| | Zeitlich Das Datum wurde erstellt und das aktualisierte Datum wurde aktualisiert. | kategorisch Weitere Informationen: http:europa.eu.int/comm/index_de.htm | numerisch Preis: ,, Quantität: ,, Score: ,, Konfidenz: |, nach Schweregrad suchen | Identität Autor, customer ID-Nr.:, SKUM, acquisition: # ]| ?" ?Alle Tickets von Kunden X-Nr:MSC7 ? | Qualität Das OCR-Konfidenzniveau von ,, automatisch generiertes -, Flaggensystem von |, ohne niedriges -, Vertrauen von OCR, " und | | Herkunft Quellesystem: ,; Dateipfad:,; URL: |; nur aus Produktionsprotokollen: ";

Tun Sie es einmal, wenn das System auf das Substrat Ihres Systems vertrauen kann.

Der harte Teil von RAG ist das Modell -, es ist alles vor dem Modell ., Für die konkreten Implementierungen siehe Aufbau eines Dokument-Zusammenfassung mit RAG und DocSummarizer, Gebäude RAG Pipelines.

Schritt: Speichern von Signalen und Evidenz halten

Statt die Einheit der Wahrheit zu behandeln", speichern Sie strukturierte Felder.,, signal.-, Dense Units, Embeddings, , und Zeiger zurück zur Quelle.

Text ist immer noch Teil des Systems, aber es wird NachweiseWas auch immer wir passierten, um in die Eingabeaufforderung einzufügen

Dies ist der Unterschied zwischen den Antworten von "-RAG sind Vibes-"- und RAG-Antworten sind inspizierbar

Aber wie weiß ich, welche Signale zu extrahieren sind?

Du bist nicht im Voraus

Das ist der ganze Punkt des Speicherns Rohsignale Anstelle von LLM---verarbeiteten Zusammenfassungen

Traditionelle RAG-Preise für Änderungen

// ❌ 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!

Reduzierte RAG-Schätzung zur Änderung von MSK

// ✅ 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')
");

Was gerade passiert ist

• Sie gespeichert mehr Signale als Sie brauchten (-Schafe)
• Wenn die Anforderungen geändert werden neu berechnet aus gespeicherten Signalen ,( , frei , )
• Du hast die LLM-Inferenz von -run auf den Dokumenten von (empfehlenswerter Zeit von+empfunden

Dies ist das gleiche Muster wie:

• DiSE - Synthetische Evolution - speichert Testergebnisse , mutation history , quality metriken . Wenn Sie die Scoring-Funktion ändern, dann führen Sie die LLM evolution — durch, indem Sie bestehende Kandidaten aus gespeicherten Signalen wieder . score
• Bot-Erkennung - speichert Anfragemuster, timing-Signale, verhalten heuristics. , wenn Sie die Schwelle anpassen 0.3 , um gespeicherte Signale zu bewerten .

Die Regel Erinnere dich gut Vorher die LLM-. , Aktualisieren Sie Ihre kostenlose " , Memory , " , ( , retrieval Logik ,) , kostenlos

Wichtigster architektonischer Nutzen:-Evolvierbarkeit.- Weil du deterministische Signale neben Embeddings speichern nicht anstelle von ihnen, kann jeder Teil des Systems unabhängig ändern ,. , Swap-Embedding-Modelle , ? , Re , - ,embed ohne Berührung von Signalen , und fügen Sie ein neues Signal .? , Berechnen Sie es aus gespeicherten Text ohne re ,. , Tune Ranking , ? , anpassen Signalgewichte und Scoring-Logik ohne Neuindexierung

Mit Multi---Vector Stores können Sie sogar hinzufügen Mehrfacheinbettungen pro DokumentSie möchten ein neues Embedding-Modell ausprobieren??? Fügen Sie es neben dem bestehenden und allmählichen Übergang hinzu..... Test sowohl in der Produktion als auch im Vergleich zu Qualität!,? dann deprecate the old one.

Jede Komponente kann sich entwickeln, ohne eine vollständige Pipeline wieder aufzubauen und ohne die anderen zu degradieren.

Welche Signale sollten Sie speichern?

Speichern Sie alles, was Sie berechnen können billig und deterministisch.

Wichtig Signale sind nur Kurztext Zeichenketten,-Nummern, und BooleansNicht riesige Datenstrukturen, nicht große Daten-Strukturen, Sie speichernde 'e "e Leistungsfähigkeit, nicht chars, nicht "e Kunde beschwerte sich über langsame Ladezeiten, nicht lange Zeit

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
}

Kostenvergleich für die Lagerung

Signale sind Verkleinerte als Text Verkleinerte als LLM Zusammenfassungen und unendlich billiger zum recomputieren von (, weil du einen LLM-). nicht brauchst

Wenn du merkst, dass du ein anderes Signal brauchst Berechnen Sie es einfach aus dem gespeicherten Rohdaten-Speicher ist billig - ;. LLM-Inferenz ist teuer -..

Aus diesem Grund ist "-over---extrahieren"- ist sicher :-Sie zahlen einmal im Speicher nicht wiederholt in der Inferenz (-substantial

Schritt Suche ohne eine LLM Suche ohne die meisten Abfragen

Die meisten Suchanfragen sind wirklich nur Suchabfragen mit Einschränkungen

• Nur die neuesten docs
• Nur für britische Kunden
• Nur der bezahlte Plan
• Nur Fehler der letzten Woche

Traditionelle RAG Preiswertes, unzuverlässiges, nicht zuverlässiges

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

Reduzierte RAG BESCHÄFTIGUNG UND ENTWICKLUNG

// ✅ 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}
");

Was gerade passiert ist

• Datenbank wurde deterministisch gefiltert
• LLM sieht Quellen statt 50, (90%, Token-Reduktion.
• Filter sind garantiert, ,, nicht empfohlen

Dies ist, warum hybride Suche in der Produktion wichtig ist. Hybride Suche ist das praktischste Stück der gesamten RAG-Serie

Optional: Verwendung eines LLM zum Extrahieren von Absichten als Vorschlag

Wenn eine Abfrage wirklich unordentlich ist kann Verwenden Sie ein kleines Modell, um Intent zu extrahieren./.filters.Vergleich mit explain vs Troubleshooting.

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

Kernprinzip: Das LLM schlägt vor, die deterministische Schicht zu validieren.

Dies ist die Grundlage der Beschränkte Fuzziness Muster, Muster und Modelle

Für einen tieferen Sprung in ephemere Ausführungsmuster, bei denen Sie LLMs vorübergehend verwenden, ohne ihre Ausgänge zu verharren, siehe Feuer und Don.'. nicht ganz vergessen.

Schritt 4:-LLMs als Synthesemotoren

Erst nach dem Abrufen nennen Sie das LLM-..Sie geben ihm einen kleinen, expliziten Satz von Fakten mit Beweiszeigern und klaren Unsicherheitsanweisungen.

Das Modell„'"s job„ :" synthetisieren, erklären, vergleichenNicht : Constraints durchsetzen – , , entscheiden Sie über die Wahrheit –, , erfinden Sie Struktur.

Wenn Sie sich um das Ziehen des gesamten Kontextfensters in die Antwort interessieren, dann haben Sie bereits den Fehler-Modus gesehen. Beschränkte Fuzzy Kontext DrackgingEs ist nicht schädlich, es zu tun, was du sie gebeten hast.

Warum das sicherer ist und billiger

Kostenvergleich

Bestellen--von---Magnitudenvergleich für einen typischen Kundensupport RAG-System

Szenario: Support-Tickets für ,, Abfragen pro Tag

Anflugkosten Kosten für die Einnahme Kosten pro Tag Kosten pro Monat |----------|----------------|----------------|------------| | Traditionelle RAG Einbetten von Tickets für 10, Tickets für |, Brocken für ×, großen KontextTag | | Reduzierte RAG +-Extraktsignale einbetten |-Extrahierende Signale Ms K3-Extraktionsstücke kleiner Kontext |-Extrict-SignaleTag |

Magnitudenordnung Kostenreduzierung pro Tag

Noch besser. Mit guten Evidenz und deterministische Filterung... du brauchst wahrscheinlich ein Grenzmodell überhaupt nicht... ein lokales Ollama-Modell... ..(frei)... mit einem kleinen Evidence Pack, das GPT--4... gefüttert wird.

Plus reduzierte Debugging-Zeiten , weniger Unterstützung Eskalationen , und Modellflexibilität Modelle ohne architektonische Veränderungen ).

Zuverlässigkeit

Traditionelle RAG Filtern auf der Grundlage von ):

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

Reduzierte RAG Verstärkte Filterung

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

Warum es sicherer ist Filter werden vor der Generierung durchgesetzt.( model nie im Besitz von ihnen, kann ' nicht vergessen, und Halluzinationen sind durch die Beweise begrenzt, die Sie kontrollieren.

Erklärbarkeit

Traditionelles RAG-: Das Modell sagte dies, ,, aber I'm nicht sicher, warum oder welches Stück kam es von .."

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

Sie können inspizieren, warum jedes Ergebnis übereinstimmend zeigt Beweis, wenn das Vertrauen niedrig ist , und Debug-Produktionsfragen durch die Prüfung der Kandidaten vor LLM Synthese gesetzt

Erste Schritte :-Refactoring traditionelle RAG reduziert

Wenn Sie bereits ein funktionierendes RAG-System hier haben, wie man migriert

Schritt -1:. Fügen Sie strukturierte Felder, um Ihre Aufnahme

Vorangehend

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

Nach-:

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
}

Schritt: Filter aus den Eingabeaufforderungen heraus in Abfragen verschieben

Vorangehend

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

Nach-:

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

Schritt 3:-Hybridsuche hinzufügen (-BMK2-+-Vektor

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

Siehe Hybride Suche für eine komplette Implementation

Schritt Messen Sie den Unterschied

Verfolgen Sie diese Metriken vor und nach

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
}

Faustregel

Wenn Ihr System von ever---größeren Kontextfenstern abhängig ist, um genau zu bleiben... Sie haben ein Retrieval-Problem.

Musterkarte

Zusammenfassung: Das reduzierte RAG-Geistmodell

Reduzierte RAG ist Anti--LLMM. Es 's Anti--Restmittel.

Denken Sie daran auf diese Weise.

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

Die Verschiebung

• Von: : LLM als Orakel macht alles
• Zu ,:' LLM als Synthese-Engine macht eine Sache gut

Die Primitiven

1. Signale (-deterministisch )-dates ,-Kategorien,-Scores,-Filter
2. Nachweise Das, was du der LLM zeigst
3. Einschränkungen (-Grenzwerte )-Markenbudgets ,-Filtervalidierung ,-Zitatanforderungen

Das Muster

• Extrahieren von Signalen einmal
• Filter deterministisch sind Datenbanken gut darin
• Hybride Suche (-BM-25-+-Vektoren
• Synthesize gebundene kleine Evidenzpackung

Es ist das, was passiert, wenn Sie normale Software-Engineering-Disziplin auf Systeme anwenden, die Sprachmodelle beinhalten.

Nächste Schritte

Wenn du bereit bist, dieses zu bauen

1. Einfach starten Fügen Sie ein strukturiertes Feld hinzu.
2. Erste Maßnahme Track Token zählt vor dem ,/'
3. Hybride Suche hinzufügen Implementieren Sie BM.25-Vektor mit RRF.Anleitung hier)
4. Aufbauen Sie inkrementell Don.'.t refaktor alles auf einmal

Referenzimplementierungen

• DoomSummarizer-:-Tiefforschung Verringerte RAG in der Praxis – :® Signal RRF-Fusion – ,® Entitätsprofile –,® semantische Graphenentdeckung – ,® und parallele lange --Formsynthese – alle aus einem Binärsystem
• Aufbau eines Dokument-Zusammenfassung mit RAG Praktische Umsetzungsschritte
• DocSummarizer RAG Pipeline Vollständige Ingestion-Pipeline
• AudioSummarizer Audio forensische Charakterisierung mit Lautsprecher-Diarisation
• LucidRAG Volle Web-App mit hybrider Suche
• StyloFlow-:-Signal---Driven Workflows Orchestrierungs-Engine für mehrstufige RAG-Pipelines mit bedingter Ausführung und Eskalation
• Beschränkte Fuzziness Das zugrunde liegende Muster

Verwandte Anwendung Verwendung von Nimble aus C-#Teil des Serie StyloMailEr untersucht die Bereitstellung eines gebundenen Mail-Kontexts an ein lokales Entscheidungsmodell.

Die Infrastruktur ist bereits da..-Sie müssen nur aufhören, das Kontextfenster wie eine Datenbank zu behandeln..-