Eine der einfachsten Möglichkeiten, um ein KI-System scheitern zu lassen, ist es sich zu viel merken zu lassen.

Die meisten Context-Handling-Annäherungen von " werden auf einen von zwei Fehlern heruntergekocht

• Stecken Sie alles in die Eingabeaufforderung und hoffen, dass das Modell herausfindet, was zählt
• Zusammenfassungen wiederholen und akzeptieren Drift als eine Tatsache des Lebens

Beide Ansätze sind teuer, blickdicht und über lange Horizonte instabil.

Es gibt ein besseres Muster, das zeigt, wie biologische Systeme die Kognition skalieren.

Ich nenne es Beschränkte Fuzzy Kontext Drackging (-CFCD-).-

Das Muster in einem Satz

Beschränkte Fuzzy Kontext Drackging ist ein Muster, in dem probabilistische Modelle vorschlagen, was besonders wichtig ist, aber nur deterministische Regeln dürfen diese Salience vorwärts tragen, um zukünftige Argumentation oder Generation zu beeinflussen.

Oder mehr unverblümt.

Modelle können bemerken, dass das Engineering entscheidet, was fortbesteht.

Dies ist die gleiche philosophische Spaltung wie Beschränkte Fuzziness und Beschränkte Fuzzy MoM Gerade entlang der Zeitachse statt der Entscheidungsachse.

Der Kernfehler, der den Kontext als Text behandelt

LLMs erinnern sich nicht an ".. Sie mustern -.Match über Tokens.

Wenn wir Kontext so behandeln, dass wir einfach mehr Text erhalten

• stille Drift
• inkonsequente Terminologie
• Auslaufkosten
• Zusammenfassungen, die früheren Zusammenfassungen widersprechen
• Übersetzungen, die dasselbe fünfmal umbenennen
• Kontext wird zu einer unversionierten Abhängigkeit Nicht weiß, was geändert ,, aber Ergebnisse verändert )

Längere Kontextfenster lösen dies nicht Sie verzögern nur den Fehler.

Die eigentliche Frage ist nicht wie viel Kontext, um zu halten

Was verdient es zu überleben?

Die CFCD-Regel

CFCD setzt eine harte Trennung durch

Zulässig, um fuzzy zu sein ,? , | , Erlaubt, zukünftige Einschränkungen zu werden ,? , | , |------|---------------------|--------------------------------------| Nicht verfügbar. Kontextförderung Generierung von |, ja, nicht mehr Verankerungsspeicher (Verankerung )Verankerung ohne |Ja Verankerung

Wahrscheinlichkeit kann vorschlagenDeterminismus entscheidet, was nach vorne geschleppt wird

Deterministische Mittel gleiche Eingaben gleiche Richtlinie gleiche AnkerDu kannst immer noch probabilistische Punktzahlen verwenden...... du führst sie einfach durch feste Förderung aus.......

CFCD ist, wie Sie die Vorteile des Kontexts erhalten, ohne den Preis des Kontextes zu bezahlen.

Beispiel: Zusammenfassung

Der Naive-Ansatz

• Teildokument
• Zusammenfassung jedes Stücks
• Zusammenfassung
• Drift annehmen

Dies schlägt fehl, weil

• frühe Fehler Verbindung
• Schwerpunktverschiebungen willkürlich
• Widersprüche sind verborgen

CFCD-Ansatz

Die wichtigsten Erkenntnisse Salience-Erkennung erfordert eine LLMSie können deterministische ML verwenden, um zu finden, was zählt.,. dann drücken Sie die LLM nur zu sehen, was überlebte Auswahl...

DocSummarizer implementiert dies

1. Parse-Dokument in Segmente ](-Sentenzen ®,-Positionen ?,-Listen Â,-Codeblöcke
2. Einbettungen erzeugen mit einem ONNX-Satz von nicht LLM---Transformatoren
3. Berechnen von Salience-Werten Verwendung von :-
   • Cosine Ähnlichkeit zu dokumentieren Zentrioid
   • TF.-.IDF für die Bedeutung des Begriffs
   • Positionsgewichte Intro/ Boost Conclusion
   • Inhalt--Typ-Anpassungen (-narrative vs expository
4. Wählen Sie nach oben mit MMR Maximale Marginal-Relevanz
   • Gleichwertigkeit gegenüber Zentrioiden mit Diversität
   • Deterministisch ,: , gleiche Eingänge , → ,selbe Auswahl
5. LLM-Synthesen nur aus ausgewählten Segmenten

Das LLM sieht nie das vollständige Dokument, es erzeugt um die Anker, nicht durch sie.

// From DocSummarizer: SegmentExtractor.cs
public class SegmentExtractor
{
    private readonly OnnxEmbeddingService _embeddingService;  // ML, not LLM

    public async Task<ExtractionResult> ExtractAsync(string docId, string markdown)
    {
        // 1. Parse document into typed segments
        var segments = ParseToSegments(docId, markdown);

        // 2. For large docs: semantic pre-filtering with multi-anchor approach
        //    - Guaranteed coverage: first/last sentences per section, constraints
        //    - BM25 candidate generation with pseudo-query from TF-IDF terms
        //    - Topic anchors via k-means clustering on sample embeddings
        if (segments.Count > _config.MaxSegmentsToEmbed)
        {
            (segmentsToEmbed, centroid) = await SemanticPreFilterAsync(segments, targetCount);
        }
        else
        {
            await GenerateEmbeddingsAsync(segments);
            centroid = CalculateCentroid(segments);
        }

        // 3. Score by salience using MMR (deterministic)
        //    Salience = lambda * sim(segment, centroid) * position_weight * content_weight
        //             - (1 - lambda) * max_sim(segment, higher_ranked_segments)
        ComputeSalienceScores(segments, centroid, contentType);

        // 4. Return top-K as anchors for synthesis
        var topBySalience = segments
            .OrderByDescending(s => s.SalienceScore)
            .Take(Math.Max(_config.FallbackBucketSize, targetCount))
            .ToList();

        return new ExtractionResult
        {
            AllSegments = segments,
            TopBySalience = topBySalience,
            Centroid = centroid,
            ContentType = contentType
        };
    }

    /// <summary>
    /// Greedy MMR selection: balances relevance with diversity
    /// </summary>

    private void ComputeSalienceScores(List<Segment> segments, float[] centroid, ContentType contentType)
    {
        var candidates = new HashSet<Segment>(segments.Where(s => s.Embedding != null));
        var ranked = new List<Segment>();

        // Pre-compute centroid similarities with content-type adjustments
        foreach (var segment in candidates)
        {
            var baseSim = CosineSimilarity(segment.Embedding!, centroid);
            var contentWeight = ComputeContentTypeWeight(segment, contentType);
            segment.SalienceScore = baseSim * segment.PositionWeight * contentWeight;
        }

        // Greedy MMR: pick best, penalise similar, repeat
        while (candidates.Count > 0)
        {
            var best = candidates
                .Select(c => new {
                    Segment = c,
                    Score = _config.MmrLambda * c.SalienceScore
                          - (1 - _config.MmrLambda) * MaxSimToRanked(c, ranked)
                })
                .OrderByDescending(x => x.Score)
                .First();

            best.Segment.SalienceScore = 1.0 - ((double)ranked.Count / segments.Count);
            ranked.Add(best.Segment);
            candidates.Remove(best.Segment);
        }
    }
}

Adaptive Auswahl – Sensibilisierung für das Kontextfenster

Da die Ausgabe ist ein Rangfolge der SammlungSie können die Ankerzahl an das Synthesemodell zur Laufzeit anpassen.

public class AdaptiveSynthesizer
{
    public int ComputeAnchorBudget(ModelProfile model, ExtractionResult extraction)
    {
        // Larger context windows → more anchors
        var baseTokenBudget = model.ContextWindow / 4;  // Reserve 25% for output

        // More powerful models → can handle more complex synthesis
        var complexityMultiplier = model.Tier switch
        {
            ModelTier.Small => 0.5,   // tinyllama: fewer, simpler anchors
            ModelTier.Medium => 1.0,  // llama3.2:3b: standard
            ModelTier.Large => 1.5,   // llama3.1:8b+: more context, nuanced synthesis
            _ => 1.0
        };

        var anchorBudget = (int)(baseTokenBudget * complexityMultiplier / _avgTokensPerSegment);

        // Never exceed what we have
        return Math.Min(anchorBudget, extraction.TopBySalience.Count);
    }

    public async Task<Summary> SynthesizeAsync(
        ExtractionResult extraction,
        ModelProfile model)
    {
        var budget = ComputeAnchorBudget(model, extraction);

        // Take top-K from already-ranked segments
        var anchors = extraction.TopBySalience.Take(budget).ToList();

        // Synthesis model only sees what survived selection + adaptation
        return await _llm.SynthesizeAsync(anchors, model);
    }
}

Dies ist immer noch deterministisch. gleichen Eingängen gleichen Modellprofils gleichen AnkernDie Rangfolge geschieht einmal, die Anpassung an ; ist nur ein Schnitt.

Dies bedeutet, dass Sie können.

• Verwenden Sie ein schnelles kleines Modell mit Ankern für kurze Zusammenfassungen
• Verwenden Sie ein leistungsstarkes Modell mit Ankern für eine umfassende Analyse
• Dynamische Einstellung der Mid---Pipeline, wenn dem ersten Versuch die Abdeckung fehlt

Die wichtigsten Erkenntnisse Anker sind Struktur, nicht ProsaDie Einbettungen und MMR sind deterministisch...... Die LLM macht nur die endgültige Synthese, die durch das, was überlebt hat, begrenzt wird....

Ankerkontrakt Die Generation kann die Phrasierung variieren, muss aber nicht den Ankern widersprechen.Wenn die Anker unzureichend sind, muss sie sich absichern und / oder mehr Beweise anfordern.

Ein Betonanker-Darstellung

{
  "policyVersion": "cfcd-v1",
  "segments": [
    {"id":"seg-12","text":"Reset requires holding button 10s","salience":0.92},
    {"id":"seg-45","text":"Factory reset clears all settings","salience":0.88}
  ],
  "coverage": "3.2% semantic sample",
  "hedging": "sampled 3% - avoid definitive conclusions"
}

Beispiel: Übersetzungsbeispiel: Lateral Dragging

Übersetzung entlarvt dieses Muster noch deutlicher

Der Fehlermodus

Übersetze den Satz von - und du erhältst den Satz

• inkonsequente Terminologie
• umbenannte Einheiten
• Subtile semantische Drift

Selbst mit einem riesigen Kontextfenster – Modelle immer noch frei fühlen – "... um Phrasierung zu variieren

CFCD-Ansatz

1. Früh im Dokument Extrakt terminologische Kandidaten:
   • richtige Substantive
   • Fachbegriffe
   • wiederholte Sätze
2. Aufbau einer Begriffsbuch:
   • Quelle Ziel-Mapping
   • Vertrauen
   • Erster Standort des -
3. Für jeden Satz
   • Fuzzy-Übersetzung erlauben
   • Beschränkung Entscheidungen mit Hilfe des Buchs
   • nur mit starken lokalen Beweisen Abweichung zulassen
4. Aktualisieren Sie das Buch deterministisch, wenn
   • ein besseres Mapping erscheint wiederholt
   • oder ein expliziter Override deklariert wird

Was als starke lokale Evidenz zählt

• Der Begriff erscheint in einem Glossar, einer Tabelle oder einem Definitionsblock
• Explizites Benutzerüberschreiben in der Konfiguration
• Wiederholt innerhalb der letzten W-Bruchpunkte mit konsistenter Nutzung

Dies ist deterministisch ,: , strukturelle Queues werden durch Muster oder Parser-Klassifikation , nicht Modell Urteil , . , erkannt

Standard-Policy-Regeln für das Vertrauen in :-Konfidenzlücken von ,-Blutstücke pro Domäne ).-Blöcke

public class TermLedger
{
    private readonly Dictionary<string, TermMapping> _mappings = new();

    public record TermMapping(
        string SourceTerm,
        string TargetTerm,
        float Confidence,
        string FirstSeenChunkId,
        int LastSeenChunkIndex,               // Track recency
        int VotesForCurrentTarget,
        int TotalVotes,                       // Preserve history
        string? ChallengerTarget = null,
        int ChallengerVotes = 0,
        float ChallengerConfidence = 0);

    public void ProposeMapping(string source, string target, float confidence, string chunkId, int chunkIndex)
    {
        source = source.ToLowerInvariant().Trim();

        if (_mappings.TryGetValue(source, out var existing))
        {
            if (existing.TargetTerm == target)
            {
                // Same as current: accumulate votes
                _mappings[source] = existing with
                {
                    Confidence = Math.Max(existing.Confidence, confidence),
                    VotesForCurrentTarget = existing.VotesForCurrentTarget + 1,
                    TotalVotes = existing.TotalVotes + 1,
                    LastSeenChunkIndex = chunkIndex
                };
            }
            else if (existing.ChallengerTarget == target)
            {
                // Same as challenger: accumulate challenger votes
                var newChallengerVotes = existing.ChallengerVotes + 1;
                var newChallengerConfidence = Math.Max(existing.ChallengerConfidence, confidence);

                // Switch if challenger has >= 2 votes AND higher confidence
                if (newChallengerVotes >= 2 && newChallengerConfidence > existing.Confidence)
                {
                    // Swap: old current becomes challenger, challenger becomes current
                    _mappings[source] = existing with
                    {
                        TargetTerm = target,
                        Confidence = newChallengerConfidence,
                        VotesForCurrentTarget = newChallengerVotes,
                        TotalVotes = existing.TotalVotes + 1,
                        LastSeenChunkIndex = chunkIndex,
                        ChallengerTarget = existing.TargetTerm,  // Preserve old mapping as challenger
                        ChallengerVotes = existing.VotesForCurrentTarget,
                        ChallengerConfidence = existing.Confidence
                    };
                }
                else
                {
                    _mappings[source] = existing with
                    {
                        ChallengerVotes = newChallengerVotes,
                        ChallengerConfidence = newChallengerConfidence,
                        TotalVotes = existing.TotalVotes + 1,
                        LastSeenChunkIndex = chunkIndex
                    };
                }
            }
            else if (confidence > existing.ChallengerConfidence)
            {
                // New challenger replaces old challenger
                _mappings[source] = existing with
                {
                    ChallengerTarget = target,
                    ChallengerVotes = 1,
                    ChallengerConfidence = confidence,
                    TotalVotes = existing.TotalVotes + 1,
                    LastSeenChunkIndex = chunkIndex
                };
            }
        }
        else
        {
            _mappings[source] = new TermMapping(
                source, target, confidence, chunkId, chunkIndex,
                VotesForCurrentTarget: 1, TotalVotes: 1);
        }
    }

    public string? GetCanonicalTranslation(string source)
    {
        source = source.ToLowerInvariant().Trim();
        return _mappings.TryGetValue(source, out var mapping)
            ? mapping.TargetTerm
            : null;
    }
}

In der Praxis willst du auch Stimmenzerfall oder ein Schiebefenster, also frühe Fehler werden permanent, . Der Schlüssel ist, dass die Zerfallsregel deterministisch, nicht model, -, beschlossen wird.

Warum dies für das Debugging von Bedeutung ist Wenn die Übersetzung Flips "-Fabrik zurückgesetzt wird, können Sie das Buch unterscheiden und genau sehen, wann und warum.

chunk-12: "factory reset" → "Werkseinstellungen" (votes: 3, conf: 0.82)
chunk-47: challenger "Zurücksetzen" reaches 2 votes, conf: 0.91
chunk-47: SWITCH - "factory reset" → "Zurücksetzen" (old mapping preserved as challenger)

Keine Vermutungen ,. , Nein ." , das Modell gerade entschieden , ". , Unsichtbar , , , deterministisch , , , auditierbar ,

Dies gibt Ihnen ,: ,

• lokale fluency - Modellhandgriffe Phrasierung - )
• Globale Konsistenz (-ledger durchgesetzt Terminologie
• Begrenzte Kosten Keine Notwendigkeit, für Konsistenz zu re-- Übersetzen
• auditierbare Entscheidungen (-ledger ist inspizierbar)

Deshalb terminologische Kohärenz kann nicht durch mehr Kontext gelöst werden

Dies ist nicht Speicher .- . Es ist Beschränkung Propagation

CFCD nicht nicht geben Sie das Modell-Speicher

Es gibt System Speicher-.-

Das Modell

• nicht tragen Zustand
• entscheidet nicht, was anhält
• nicht eigener Kontext

Das System

• Speicheranker
• erlegt Grenzen auf
• erlischt veralten Salience
• kontrolliert explizit die Lebensdauer

Ablaufbestimmungen Nicht modelliert, nicht modelisiert, nicht deterministisch

• Zeit---basiert -:- Anker verfallen nach T ohne Berücksichtigung
• Verwendung von -, basierend auf : Anker mit Null Treffern über N nachfolgende Brocken zerfallen
• Kontradiktions--, basierend auf : Herausforderer hat Stimmen und übertrifft das aktuelle Vertrauen durch Δ,- innerhalb eines Schiebefensters von W Stücken

Diese Unterscheidung ist alles.

flowchart TB
    subgraph Model["Probabilistic Model"]
        M1[Detect Salience]
        M2[Generate Output]
    end

    subgraph System["Deterministic System"]
        S1[Promote Anchors]
        S2[Store in Ledger]
        S3[Enforce on Generation]
        S4[Expire Stale Context]
    end

    M1 --> S1 --> S2
    S2 --> S3 --> M2
    S2 --> S4

    style Model stroke:#f59e0b,stroke-width:2px
    style System stroke:#22c55e,stroke-width:3px

Die CFCD-Pipeline

Hier ist das Muster mit dem Ledger als erstes - --Klasse Objekt.

flowchart LR
    S[Stream: chunks/sentences] --> M[Model proposes salience]
    M --> P[Promotion rules]
    P --> L[Ledger / Anchors]
    L --> G[Generation constrained by anchors]
    G --> O[Output]
    L --> E[Expiry rules]
    E -.-> L

    style L stroke:#22c55e,stroke-width:3px
    style P stroke:#22c55e,stroke-width:2px
    style E stroke:#22c55e,stroke-width:2px
    style M stroke:#f59e0b,stroke-width:2px
    style G stroke:#f59e0b,stroke-width:2px

Die grünen Kästen sind deterministisch, die orangen Boxen sind probabilistisch, das Buch sitzt zwischen ihnen und hält, was überlebt hat.

Was ändert sich in der Praxis?

Drei Schichten

• Du hörst auf, prosa zu bleiben.
• Sie bleiben bestehen. getippte Anker
• Du behandelst das Buch als API-Datei, nicht als Eingabeaufforderung

Die Eingabeaufforderung wird Ansicht nicht das Buch selbst

Dass die ' den Moment der " Das Buch ist nicht Kontext Es ' ist ein Vertrag

Was als Anker zählt

Anker sind nicht wichtiger Text typisierte, strukturierte Fakten dass die Generation eingeschränkt wird.

• Terminologie-Mappings: factory reset → restore factory settings
• Einrichtungen und IDs: ProductName, ModelNumber, UserID
• Einschränkungen InvariantenDas Zurücksetzen erfordert eine Haltetaste.
• Benutzereinstellungen StilbeschränkungenVerwendet formalen Ton, ",, ", britische Rechtschreibung
• Erfassung von Metadaten:, semantische Probe, ,, Anker, ",
• Versionierung: policyVersion: "cfcd-v1", anchorSchemaVersion: 2

Der Punkt ist: :. Anker sind nicht prosa... Sie sind Struktur, das Modell schreibt um sie herum.

Biologische Ausrichtung

Dies ist eine Analogie... nicht ein biologischer Anspruch... der Punkt ist selektive Konsolidierung... nicht buchstäblicher Mechanismus...

Gehirne wiederholen nicht den gesamten Sinnesstrom.

Sie n s s

• Salience erkennen
• selektiv konsolidieren
• Lärm hemmen
• Einfrieren Darstellungen einmal stabil

Sprache – motorische Fähigkeiten – und Wahrnehmung verlassen sich alle auf Eingeschränktes Tragevermögen-Nicht rohe Rückrufe

CFCD ist das gleiche Prinzip, das mechanisch implementiert wird.

Biologisches System - CFCD Äquivalente |------------------|-----------------| Achtung, was zu bemerken ist, dass ) (, was man sich merken sollte, ), Ankerförderung (, deterministisch), MSC6, |-Hemmung, was zu ignorieren ist, )-Steigerung, Expiration Rules Weitere Informationen finden Sie unter: http:europa.eu.int

Die Muster vereinen

CFMoM und CFCD sind die gleiche Idee aus verschiedenen Blickwinkeln betrachtet

|-Maße - Muster |-----------|---------| Einzelantragsteller Beschränkte Fuzziness | Mehrere Antragsteller Beschränkte Fuzzy MoM | Dauerhaftes -Horizon-Kontext Eingeschränkter Fuzzy Kontext Dragging

Alle drei gehorchen der gleichen Regel.

Wahrscheinlichkeit schlägt vor, dass der Determinismus fortbesteht

Sobald du diese Regel verinnerlichst, ist die meisten ".AI-Systemdesign nicht mehr geheimnisvoll.

flowchart LR
    subgraph CFP["Part 1: Constrained Fuzziness"]
        P1[Single Proposer] --> C1[Constrainer] --> O1[Output]
    end

    subgraph CFMoM["Part 2: Constrained Fuzzy MoM"]
        P2A[Proposer A] --> CS[Consensus Space]
        P2B[Proposer B] --> CS
        P2C[Proposer C] --> CS
        CS --> C2[Coordination Constrainer] --> O2[Output]
    end

    subgraph CFCD["Part 3: Context Dragging"]
        T1[Time T] --> A1[Anchors]
        T2[Time T+1] --> A1
        A1 --> C3[Constrained Generation] --> O3[Output]
    end

    style CFP stroke:#22c55e,stroke-width:2px
    style CFMoM stroke:#3b82f6,stroke-width:2px
    style CFCD stroke:#8b5cf6,stroke-width:2px

Warum dies nicht Mainstream ist

Weil es

• reduziert den Rechenaufwand für die Konsistenz
• Arbeitet mit kleinen Modellen, die das schwere Heben durchführen.
• sieht langweilig in einer Demo aus
• produziert weniger dramatische Ausfälle
• erfordert reale Systeme denkend nicht nur promptes Engineering

Mit anderen Worten: Es optimiert für die Produktion, nicht hype, sondern:

Anti---Patterns Dies ersetzt

Anti---Pattern-Problem-Lösung |--------------|---------|---------------| | Alles im Kontext auffüllen Nicht gebundene Kosten, Aufmerksamkeitsverdünnung, Förderung nur das, was die Auswahl überlebt. | Rekursive Zusammenfassung Anker sind Struktur, nicht Prosa | Hoffe, das Modell erinnert sich Keine Garantien System besitzt Persistenz | Per---Request Volle Re---Verarbeitung Kosten-Skala mit Geschichte | Natürliche Sprache Semantische Abdrift-Anker mit Eingetippten Ankern mit Ausprägung von Mappings für | | One---Größen-- Passt zu allen Kontexten Abfallkapazität oder -verhungermodell |-Adaptives Schneiden aus der Rangfolge Sammlung |

Umsetzungs-Substrate: äphemische

Meistlylucid, ., kurzlebig ist das Substrat, das CFCD praktisch macht, wenn Sie die Hintergrundartikel lesen

• Feuer und Don.'. nicht ganz vergessen Die Philosophie
• Ephemere Ausführung Bibliothek Die Implementierung
• Vergängliche Signale --Signal ,--gesteuerte Koordination
• LRU lernen Warum ein gebundenes Gedächtnis wichtig ist

Ephemerischer Primitivwert der CFCD-Rolle |--------------------|-----------| | Signale Weitere Informationen finden Sie unter: http:www.cordis.lu/ | Gebundene Fenster Keine ungebundenen Memorys | Räumungsvorschriften Das Vergessen ist explizit. | Ablauf des Gleitvorgangs Stale-Kontext läuft automatisch ab | Signalausbreitung Anker tragen ohne Mutation nach vorn

Ephemeres erinnert sich nicht an ". entscheidet, was erinnert werden darf und wie lange.

Das ist genau das, was CFCD erfordert.

public class CFCDCoordinator
{
    private readonly SignalSink _sink;
    private readonly TermLedger _ledger;
    private readonly TimeSpan _anchorLifetime = TimeSpan.FromHours(1);

    public void PromoteAnchor(string term, string translation, string chunkId, int chunkIndex)
    {
        _ledger.ProposeMapping(term, translation, 0.8f, chunkId, chunkIndex);

        // Emit signal for observability (key = chunkId for correlation)
        _sink.Raise($"anchor.promoted:{term}", key: chunkId);
    }

    public void ExpireStaleAnchors()
    {
        var cutoff = DateTimeOffset.UtcNow - _anchorLifetime;

        // Ledger entries older than cutoff without recent usage are removed
        // This is deterministic, not model-decided
        _ledger.ExpireOlderThan(cutoff);
        _sink.Raise("anchors.expired");
    }
}

Implementation Sketch-:-Dokument Übersetzung

Zusammenbringen für eine komplette Dokument-Übersetzungspipeline

public class CFCDTranslationPipeline
{
    private readonly ILlmService _llm;
    private readonly TermLedger _ledger;
    private readonly SignalSink _sink;
    private readonly int _seedChunks = 3;  // K: configurable seed window

    public async Task<TranslatedDocument> TranslateAsync(
        Document source,
        string targetLanguage)
    {
        var chunks = Chunker.Chunk(source, maxTokens: 500).ToList();
        var translated = new List<TranslatedChunk>();

        // Phase 1: Extract terminology candidates (first pass, fuzzy)
        // Seed from first K chunks: front-loads terminology, avoids churn later
        for (var i = 0; i < Math.Min(_seedChunks, chunks.Count); i++)
        {
            var chunk = chunks[i];
            var candidates = await _llm.ExtractTerminologyAsync(chunk);
            foreach (var term in candidates)
            {
                _ledger.ProposeMapping(
                    term.Source,
                    term.ProposedTranslation,
                    term.Confidence,
                    chunkId: chunk.Id,
                    chunkIndex: i);
            }
        }

        _sink.Raise("terminology.seeded");

        // Phase 2: Translate with ledger constraints
        for (var i = 0; i < chunks.Count; i++)
        {
            var chunk = chunks[i];

            // Get canonical translations for terms in this chunk
            var constraints = ExtractConstraints(chunk, _ledger);

            // Translate with constraints (model must respect ledger)
            var result = await _llm.TranslateWithConstraintsAsync(
                chunk,
                targetLanguage,
                constraints);

            // Update ledger with any new terms (deterministic rules)
            foreach (var newTerm in result.NewTerminology)
            {
                if (ShouldPromote(newTerm, _ledger))
                {
                    _ledger.ProposeMapping(
                        newTerm.Source,
                        newTerm.Target,
                        newTerm.Confidence,
                        chunkId: chunk.Id,
                        chunkIndex: i);

                    _sink.Raise($"anchor.promoted:{newTerm.Source}");
                }
            }

            translated.Add(result.Chunk);
        }

        return new TranslatedDocument(translated, _ledger.GetAllMappings());
    }

    private bool ShouldPromote(TermCandidate term, TermLedger ledger)
    {
        // Deterministic rules, not model judgment:
        // - Proper nouns always promoted
        // - Technical terms promoted if repeated
        // - Common words never promoted
        return term.Type == TermType.ProperNoun ||
               (term.Type == TermType.Technical && term.OccurrenceCount >= 2);
    }
}

Schlussgedanken

Der Fehler, den die meisten KI-Systeme machen, ist die Annahme, dass sich Intelligenz durch Erinnerung verbessert mehr.

In der Praxis skaliert die Intelligenz, indem sie entscheidet, was Ich muss nie wieder darüber nachdenken.

CFCD ist, wie du das machst, ohne dich selbst anzulügen.

Die Reihe

Alle drei Muster teilen sich die gleichen invariant probabilistische Komponenten schlagen vor deterministische Systeme bestehen fort..

Das Zehn Gebote der LLM-Nutzung kodifizieren Sie diese Regeln DiSE-Architektur implementiert sie für die Code-Evolution. Bot-Erkennung setzt sie für die Anfrageklassifikation um DocSummarizer implementiert sie für das Dokument retrieval. ImageSummarizer setzt sie für die Bildanalyse um

Verschiedene Domänen Gleiches Muster Gleiche Regel DoomSummarizer implementiert das Ziehen des Kontextes für die parallele Langzeit---Form-Dokumentgenerierung mit Zusammenfassungen - , - negative Eingabeaufforderung - MS K3 - Entitätskontinuität -, - und Driftdetektion erhalten Kohärenz über gleichzeitige LLM-Aufrufe hinweg

Nächste Pressemitteilungen Praktische Umsetzung

Teil ist jetzt verfügbar Bild-Summarizer - Eine eingeschränkte Fuzzy Image RAG EngineEs implementiert alle drei Muster in einer Welle.-.basierten Bildanalyse-Pipeline.MSC2.ColorWave berechnet Fakten.,. VisionLmmWave schlägt vor, ,. ImageLedger sammelt wesentliche Funktionen und deterministische Auswahl schränkt den Ausgang ein.MSZ6. Clone it from github-.-com./-scottgal./-lucidrag.