StyloFlow-:, eingeschränktes Fuzzy-Signal, angetriebene Workflows (Deutsch (German))

StyloFlow-:, eingeschränktes Fuzzy-Signal, angetriebene Workflows

Sunday, 11 January 2026

//

33 minute read

Comments Raw Edit
AI Architecture C# RAG Signals Workflows

Ich baute StyloFlow, weil ich weiter schrieb das gleiche Muster immer und immer wiederKomponenten, die auf das reagieren, was passiert ist, bevor es zu einem Vertrauensscores kommt und manchmal zu einer teureren Analyse eskalieren muss. Bestehende Workflow-Engines wollten, dass ich in Bezug auf DAGs oder Staatsmaschinen denke.

HINWEIS:-StyloFlow ist nicht YET ein fertiges Produkt, wie ich lucidRAG und StyloBot I'-m Hinzufügen fehlenden Funktionen und Polieren der API auf BOTH Sty LoFllow und Ephemeral bauen ?. - es ist immer noch in der aktiven Entwicklung ., - aber Sie können versuchen, es auszuprobieren und bieten Feedback ? . - Ich werde hier später aktualisieren . ( - das SignalSink Zeug zum Beispiel wird sich ändern für ephemere v...

StyloFlow ist eine signal- ,- driven orchestrierungsbibliothek, die passt wie ich denke über KI-Pipelines: Komponenten erklären, was sie produzieren und was sie brauchen.,-Konfidenzwerte Führung Ausführung.,- und billige Operationen laufen zuerst mit Eskalation zu teuren nur bei Bedarf.

Das ist die Infrastruktur, die klarRAG Das RAG-Tool für den cross- und kreuzförmigen Graphen DocSummarizer ](-Dokumente ·),-Dokument DatenZusammenfassung Strukturierte Daten), und ImageSummarizer (-Bilder in eine einheitliche Frage --Antwortsystem mit Wissensgraphenvisualisierung .-Es macht auch Stylobot Ein fortschrittliches Bot-Schutzsystem und implementiert die Reduzierte RAG Muster, Muster und Modelle

lucidRAG Schnittstelle

Quelle: Eurostat. GitHub - MSK - StyloFlow

Was ist das?

StyloFlow ist ein funktionierender Prototyp eines Signals, das signalisiert wird Die API und die Form werden sich entwickeln, wenn ich lucidRAG und Stylobot zusammenbaue.,, aber die Ausführung Semantik und Muster hier beschrieben sind die point- und eskalation als strukturelles Muster

Dies ist eine neue DSL- oder Workflow-Sprache. Ausführung Semantik gebaut rund um Signale, ,-Konfidenz-,- und begrenzte Eskalation-MSC2-Heute läuft es im --Prozess mit begrenzter Koncurrency-.-Morgen wird es die Fahrspuren über Maschinen verteilen, während die Signale als stabile Grenze beibehalten werden.

Das Problem mit traditionellen Workflows

Hier ist, wie die meisten Workflow-Engines aussehen

// ❌ Traditional: Hardcoded dependencies
public async Task ProcessDocumentAsync(string path)
{
    var text = await ExtractTextAsync(path);
    var chunks = await ChunkTextAsync(text);
    var embeddings = await GenerateEmbeddingsAsync(chunks);
    var entities = await ExtractEntitiesAsync(chunks);
    await StoreEverythingAsync(embeddings, entities);
}

Dies funktioniert bis zum

  • Sie möchten Entity-Extraktion für einfache Abfragen überspringen
  • Sie müssen Extraktion und Einbettung parallel ausführen
  • Sie wollen zu einem besseren Modell auf der Grundlage des Vertrauens eskalieren
  • Sie müssen eine neue Verarbeitungsstufe hinzufügen, ohne den vorhandenen Code zu berühren

Du endest mit entweder

  1. Starre Rohrleitungen die sich anpassen können
  2. Massive, wenn, / Bäume für Routing
  3. Gott Klassen die alles wissen

Die ephemere Ausführung der Stiftung

StyloFlow baut auf meistlucid-.-ephemer Eine Bibliothek für gebundene trackable async Ausführung

Schnelle Zusammenfassung dessen, was ephemeral zur Verfügung stellt

// Bounded concurrent processing with full visibility
var coordinator = new EphemeralWorkCoordinator<DocumentJob>(
    async (job, operation, ct) => {
        await ProcessAsync(job, ct);
        operation.Signal("document.processed");
    },
    new EphemeralOptions { MaxConcurrency = 4 });

// Enqueue work
await coordinator.EnqueueAsync(new DocumentJob(filePath));

// Full observability
Console.WriteLine($"Active: {coordinator.ActiveCount}");
Console.WriteLine($"Completed: {coordinator.TotalCompleted}");

Die wichtigsten Vorteile von Ephemeral-:

  • Gebundene Koncurrency Keine entlaufenen Speicher
  • LRU Räumung von alten Operationen
  • Signal-Publishing für die cross®--Komponentenkoordination
  • Operation Pinning, um eine vorzeitige Räumung zu verhindern

Für Details siehe Feuer und Don.'. nicht ganz vergessen.

Was dieses Modell ermöglicht

Diese Orchestrierung Modell erweitert ephemere mit

  1. YAML---getriebene Komponente manifestiert Beschreibungskonfiguration
  2. Signal---basierte Trigger Komponenten laufen, wenn Signale erscheinen
  3. Wellenkoordination Vorrangige Ausführung auf Basis von - mit Konkurrenzspuren
  4. Eskalationsmuster Verteidigen Sie teure Analysen, bis sie benötigt werden
  5. Verträge mit Rechtsträgern Technische Daten für die Ausgabe von -
  6. Haushaltsführung Zeitlimite für das Zeichen „MSK"

Hier ist die architektonische Schlüsselverschiebung.

graph TD
    subgraph Traditional["❌ Traditional: Hardcoded"]
        T1[Component A] -->|calls| T2[Component B]
        T2 -->|calls| T3[Component C]
        T3 -->|calls| T4[Component D]
    end

    subgraph StyloFlow["✅ StyloFlow: Signal-Driven"]
        S1[Component A]
        S2[Component B]
        S3[Component C]
        S4[Component D]
        SS[Signal Sink]

        S1 -.emits.-> SS
        S2 -.emits.-> SS
        S3 -.emits.-> SS
        SS -.triggers.-> S2
        SS -.triggers.-> S3
        SS -.triggers.-> S4
    end

    style T1 stroke:#ff6b6b
    style T2 stroke:#ff6b6b
    style T3 stroke:#ff6b6b
    style T4 stroke:#ff6b6b
    style S1 stroke:#51cf66
    style S2 stroke:#51cf66
    style S3 stroke:#51cf66
    style S4 stroke:#51cf66
    style SS stroke:#339af0

Komponenten rufen sich nie gegenseitig aus. Sie senden Signale aus und reagieren auf Signale.

Kernkonzept – Signale und Eigentum

Signale sind Fakten über das, was passiert istNicht Befehle oder Ereignisse, sondern sie sind unveränderlich., timestamped... und tragen Vertrauensnoten... Jedes Atom besitzt seine Signale... sie sind extern unwandelbar.

public record Signal
{
    public required string Key { get; init; }           // "document.chunked"
    public object? Value { get; init; }                 // Optional payload
    public double Confidence { get; init; } = 1.0;      // 0.0 to 1.0
    public required string Source { get; init; }        // Which component
    public DateTime Timestamp { get; init; }
    public Dictionary<string, object>? Metadata { get; init; }
}

Critical architectural point-:-SignalSink ist eine persistente historische Ansicht

SignalSink bietet eine abfragebare Ansicht über alle Operationen auf allen Koordinatoren, die es teilen .. .Signale bestehen über den gesamten Lebenszyklus des Koordinators ?- . wenn ein Betrieb von seinem Koordinator ausscheidet . , . die Signale bleiben im Waschbecken bis manuell gelöscht .

// Create a shared signal sink (no parameters, signals persist)
var sink = new SignalSink();

// Coordinators manage operation lifetime, NOT signal lifetime
var coordinator = new EphemeralWorkCoordinator<string>(
    ProcessAsync,
    new EphemeralOptions
    {
        MaxConcurrency = 8,
        MaxTrackedOperations = 100,         // Operations evict after this
        MaxOperationLifetime = TimeSpan.FromMinutes(5),  // Or after this time
        Signals = sink                      // Share the persistent view
    });

// Operations emit via their emitter
public async Task ProcessAsync(string docId, SignalEmitter emitter, CancellationToken ct)
{
    // Store actual data externally (cache, database, blob storage)
    await cache.SetAsync($"doc-{docId}", documentData);

    // Signal carries a REFERENCE, not the data
    emitter.Emit("document.chunked", key: docId); // Key references external data
}

// SignalSink is readonly - it cannot alter signals
// Signals persist until their operation evicts from the coordinator

SignalSink bietet ZWEI Koordinationsmuster

1.-Push---basiertes (-Subscribe-):-Subsumer

// Subscribe to the sink for push notifications
sink.Subscribe(signal => {
    if (signal.Is("document.chunked"))
    {
        // React immediately - signal includes OperationId
        Console.WriteLine($"Op {signal.OperationId} chunked doc at {signal.Timestamp}");
    }
});

// Returns IDisposable for cleanup
using var subscription = sink.Subscribe(HandleSignal);

2.-Pull---based Qery-):-Pulli

// Get all signals for a specific operation
var opSignals = sink.GetOpSignals(operationId);

// Detect if any operation has emitted a signal
if (sink.Detect("embeddings.generated"))
{
    // At least one operation has generated embeddings
}

// Sense all signals matching a condition
var recentErrors = sink.Sense(s =>
    s.Signal.StartsWith("error.") &&
    s.Timestamp > DateTimeOffset.UtcNow.AddMinutes(-5)
);

// Get operation summary from its signal history
var summary = sink.GetOp(operationId);
Console.WriteLine($"Operation ran for {summary?.Duration}");

Warum das so wichtig ist

  • Nur-Leseansicht SignalSink kann die Signale nicht verändern, es bietet nur Abfragezugriff
  • Signale bleiben bestehen Die Signale bleiben in der Ansicht, bis ihre Operation vom Koordinator entfernt wird.
  • Signale sind Koordination, nicht Transport Signale tragen Schlüssel , /Bezug auf externe Daten , nicht die Daten selbst
  • Unabhängigkeit des Koordinators Mehrere Koordinatoren können eine Senke teilen, die alle über die Signalgeschichte hinausgeht.
  • Thread---sicher Verriegelung von -®free liest für Abfrageoperationen
  • Drücken und ziehen (), für reaktive ,, Sense, ()/, Detect,(), für Umfragen
  • Operationskorrelation Jedes Signal enthält OperationId zur Nachverfolgung über Koordinatoren hinweg.
  • Musterabgleich Abfrage durch exakte Übereinstimmung - Präfix , oder benutzerdefiniertes Prädikat

Grundprinzip des Entwurfs Speichern Sie große Daten Dokumente ,.Images,.Vektoren ). in Caches oder Datenbanken "cache://doc-123" oder Betriebstasten

Beispielkoordination

// Operation emits signal via ISignalEmitter interface
public async Task ProcessAsync(Item item, ISignalEmitter emitter, CancellationToken ct)
{
    // Emit to the sink
    emitter.Emit("processing.started");

    await DoWorkAsync(item, ct);

    emitter.Emit("processing.completed");
}

// Wave checks if it should run by querying sink
public bool ShouldRun(string path, AnalysisContext ctx)
{
    // Pull pattern: query the sink via context
    return ctx.Detect("document.chunked");
}

// UI subscribes to sink for reactive updates
sink.Subscribe(signal => {
    if (signal.Signal.StartsWith("document."))
    {
        // Push pattern: react immediately
        UpdateProgressUI(signal);
    }
});

Eskalation findet auf zwei Ebenen statt

  1. Im Rahmen eines Koordinators Die Wellen überprüfen das Signalvertrauen und führen eine bedingt teure Analyse durch.
  2. Zwischen den Koordinatoren EskalatorAtm-Routen Signale von schnellen Koordinatoren. - teurer Koordinator basierend auf Signalkriterien
// Pattern 1: Intra-coordinator escalation (wave checks signals)
public bool ShouldRun(string path, AnalysisContext ctx)
{
    var quality = ctx.GetSignal("quality.score");
    return quality?.Confidence < 0.7; // Only run if quality is low
}

// Pattern 2: Inter-coordinator escalation (atom routes to another coordinator)
// Option A: Explicit escalation signal
typed.Raise("escalate.to.expensive", payload, key: "doc-123");

// Option B: EscalatorAtom examines signals and decides
new EscalatorAtomOptions<T> {
    ShouldEscalate = evt => evt.Payload.Confidence < 0.7
}

Mehrere Koordinatoren laufen unabhängig .. .Eskalator Atom beobachtet Signale von einem Koordinator und leitet Arbeit an einen anderen weiter, wenn erforderlich .

Für die Theorie, die dahinter steht, siehe Beschränkte Fuzzy Kontext Drackging.

Signale tragen Referenzen ,, , keine Daten

Kritisch , : Signale sind Koordinationsereignisse,- nicht Datentransport.- große Daten Dokumente,-Bilder,-Embeddings)- sollten im externen Speicher leben

// ❌ BAD: Carrying data in signals (memory pressure, boxing)
var imageBytes = await ProcessImageAsync(input);
emitter.Emit("image.processed", metadata: new { Data = imageBytes });

// ✅ GOOD: Store externally, signal the reference
var imageBytes = await ProcessImageAsync(input);
var cacheKey = $"processed/{docId}";
await cache.SetAsync(cacheKey, imageBytes);
emitter.Emit("image.processed", key: cacheKey);

// Later: Retrieve when needed
if (sink.Detect("image.processed"))
{
    var signals = sink.GetOpSignals(operationId);
    var imageKey = signals.FirstOrDefault(s => s.Signal == "image.processed")?.Key;
    if (imageKey != null)
    {
        var bytes = await cache.GetAsync<byte[]>(imageKey);
    }
}

Bewährte Verfahren

  • Caches für ephemere Daten verwenden
  • Datenbanken für dauerhafte Daten verwenden
  • Blob-Speicher für große Dateien verwenden
  • Signal-URIS-: "cache://key", "blob://container/file", "db://table/id"
  • Bewahren Sie die Signale leicht und einfach auf den Schlüsseln.

Kernkonzept:-Komponenten-Manifestierungen

Manifeste erklären Verträge, die mich auslösen, was ich emittiere. Diese Trennung existiert, so dass Sie den Workflow verstehen können, ohne Code zu lesen und die Ausführungsreihenfolge zu ändern, ohne erneut zu kompilieren.

name: BotDetector
priority: 10              # Lower runs first
enabled: true

# What kind of component is this?
taxonomy:
  kind: analyzer          # sensor|analyzer|proposer|gatekeeper
  determinism: probabilistic
  persistence: ephemeral

# When should this run?
triggers:
  requires:
    - signal: http.request.received
      condition: exists

# What does it produce?
emits:
  on_complete:
    - key: bot.detected
      confidence_range: [0.0, 1.0]

  conditional:
    - key: bot.escalation.needed
      when: confidence < 0.7

# Resource limits
lane:
  name: fast              # fast|normal|slow|llm
  max_concurrency: 8

budget:
  max_duration: 100ms

# Configuration values
defaults:
  confidence:
    bot_detected: 0.6
  timing:
    timeout_ms: 100

Vorteile

  1. Laufzeitumstellung Priorität ändern, ohne erneut zu kompilieren
  2. Umweltüberschreitungen Überschreiben Sie über Appsettings.
  3. Klare Verträge Sehen Sie, welche Signale auslösen, was
  4. Selbstbeherrschung Das Manifest ist das Spezifik

Visual Workflow Builder

Während Sie YAML Manifeste per Hand schreiben können, enthält StyloFlow einen visuellen Workflow-Builder, mit dem Sie signalisierte Workflows mithilfe modularer --Synth---Style-Patching erstellen können.

StyloFlow Workflow Builder

Die Benutzeroberfläche stellt zur Verfügung.

  • Drag--- und ---Drop Komponenten aus der Taxonomie (-Sensoren ,-Analysatoren ,-Proposer , usw. .)-
  • Signaldraht-Patching Verbinde Ausgänge visuell mit Eingängen
  • Live-Manifestvorschau Sehen Sie die erzeugte YAML, wie Sie bauen
  • Visualisierung auslösen Sehen Sie, welche Signale auslösen welche Komponenten
  • Streckenzuweisung Komponenten in schnelle, normale und langsame Bahnen ziehen
  • Echtzeit-Validierung Fangen Sie ungültige Signalreferenzen sofort

Dies macht es einfach, mit verschiedenen Workflow-Formen zu experimentieren, ohne YAML per Hand zu schreiben.

Kernkonzept:-Wellen

Eine Welle ist ein komposables Analysestadium. Diese Schnittstelle existiert, um zu machen, dass wir eine erste Entscheidung für die -Nicht ein Implementierungs-Detail in bedingter Logik begraben

public interface IContentAnalysisWave
{
    string Name { get; }
    int Priority { get; }               // Higher runs first
    bool Enabled { get; set; }

    // Quick filter - avoid expensive work
    bool ShouldRun(string contentPath, AnalysisContext context);

    // Do the analysis
    Task<IEnumerable<Signal>> AnalyzeAsync(
        string contentPath,
        AnalysisContext context,
        CancellationToken ct);
}

Einfaches Wellenbeispiel

public class FileTypeWave : IContentAnalysisWave
{
    public string Name => "FileType";
    public int Priority => 100;
    public bool Enabled { get; set; } = true;

    public bool ShouldRun(string path, AnalysisContext ctx)
    {
        // Skip if we already know the type
        return ctx.GetSignal("file.type") == null;
    }

    public async Task<IEnumerable<Signal>> AnalyzeAsync(
        string path,
        AnalysisContext ctx,
        CancellationToken ct)
    {
        var extension = Path.GetExtension(path);
        var mimeType = GetMimeType(extension);

        return new[]
        {
            new Signal
            {
                Key = "file.type",
                Value = mimeType,
                Confidence = 1.0,
                Source = Name
            }
        };
    }
}

Wellenkoordination

Das WaveCoordinator läuft Wellen in Prioritätsreihenfolge

var coordinator = new WaveCoordinator(waves, profile);
var context = new AnalysisContext();

var results = await coordinator.ExecuteAsync(filePath, context, ct);

// All signals from all waves
foreach (var signal in context.GetAllSignals())
{
    Console.WriteLine($"{signal.Key}: {signal.Value}");
}

Fahrspuren für die Konkurrenz ,:

Wellen laufen in Lanes mit unterschiedlichen Concurrency Limits

LÄNDERBEZOGENE ENTWICKLUNG |------|---------|-------------| | fast Kurze Überprüfungen der ('IP-Suchen der Datei Typ )|'16« | normal Standard-Verarbeitungsschritte für (Parsing-Prozesse für,Prunking-Verfahren für )Prinking-Effekte | io /O gebundene Datei liest die API-Aufrufe der ,, ), |,32 und | | llm Teuere LLM-Aufrufe

Dies verhindert, dass teure Operationen billige blockieren

Architektur, wie es zusammenpasst

Hier ist das komplette Bild.

graph TB
    subgraph Input["Input Layer"]
        REQ[HTTP Request]
        FILE[File Upload]
        JOB[Background Job]
    end

    subgraph Ephemeral["Ephemeral Layer"]
        COORD[Work Coordinator]
        OPS[Operations<br/>own signals]
        SINK[SignalSink<br/>read-only view]
    end

    subgraph StyloFlow["StyloFlow Layer"]
        MAN[Manifests]
        WAVE[Wave Coordinator]
        ATOMS[Atoms<br/>own signals]
    end

    subgraph Execution["Execution"]
        FAST[Fast Lane]
        NORM[Normal Lane]
        LLM[LLM Lane]
    end

    subgraph Output["Output"]
        RES[Results]
        ESCAL[Escalation]
        STORE[Persistence]
    end

    REQ --> COORD
    FILE --> COORD
    JOB --> COORD

    COORD --> OPS
    SINK -.queries.-> OPS

    WAVE -.reads.-> SINK
    MAN -.configures.-> WAVE
    WAVE --> ATOMS

    ATOMS --> FAST
    ATOMS --> NORM
    ATOMS --> LLM

    SINK -.queries.-> FAST
    SINK -.queries.-> NORM
    SINK -.queries.-> LLM

    SINK -.read for.-> RES
    SINK -.read for.-> ESCAL
    SINK -.read for.-> STORE

    style COORD stroke:#339af0
    style SINK stroke:#339af0
    style WAVE stroke:#51cf66
    style ATOMS stroke:#51cf66

Durchfluss

  1. Eingabe kommt an (-HTTP Anfrage ,-Datei ,-Job
  2. Ephemere Koordinator erstellt Operation .( , die eine leere Signalliste besitzt .
  3. Betrieb fügt Signale zu seiner eigenen Liste hinzu
  4. Wave-Koordinator READS Signale über SignalSink Ansicht, um Triggerbedingungen zu überprüfen
  5. Wellen, deren Trigger übereinstimmen, laufen in Prioritätsreihenfolge innerhalb von Parallelspuren
  6. Jede Welle fügt Signale zu seinem Betrieb bei.' s owned list extern unveränderlich
  7. Wave-Koordinator liest Signale weiter, um neue zufriedene Auslöser zu finden
  8. Endgültige Ausgabeabfragen SignalSink, um Signale zu lesen und Aktionen zu bestimmen

Eigentümermodell - : Jede Operation, die /-Atom besitzt seine Signale, .-SignalSink bietet eine Lese---Nur-Ansicht über alle Operationen,.-Signale können eskaliert werden, )- oder echoisierte (-Empfänger erhalten, wenn ausgelöscht wird, aber die eigene Liste ist extern unveränderlich..

Aktueller Ausführungsmodell Einmaliger --Prozess, gebundene Koncurrency-Operationen, beobachtbare Operationen mit LRU-Eviktion

Künftiges Ausführungsmodell Verteilte Fahrspuren auf Maschinen - SignalSink Abfragen Remote-Operationen - Atome führen auf verschiedenen Hosts aus Signale bleiben die stabile Grenze ' ist bereits serialisierbar, , timestamped, und selbst- integriert Das Eigentumsmodell ändert sich nicht.

Die Implementierung des in---Prozesses bestätigt die Semantik-Distribution bei der Skalierung des Ausführungssubstrates ,, , ohne das Orchestrierungsmodell zu verändern

Case-Verarbeitung von Dokumenten verwenden

Mal sehen, wie LucidRAG verwendet StyloFlow-:

Stadium der ersten Detektion

public class FileTypeDetectorWave : IContentAnalysisWave
{
    public int Priority => 100;  // Run first

    public async Task<IEnumerable<Signal>> AnalyzeAsync(...)
    {
        var extension = Path.GetExtension(path);

        return new[]
        {
            new Signal
            {
                Key = "file.extension",
                Value = extension,
                Source = "FileTypeDetector"
            }
        };
    }
}

Stufe 2:-Cunking, ausgelöst durch Datei .-Extension)-

// In manifest:
// triggers:
//   requires:
//     - signal: file.extension
//       condition: in
//       value: [".pdf", ".docx", ".md"]

public class ChunkingWave : ConfiguredComponentBase, IContentAnalysisWave
{
    public int Priority => 80;

    public async Task<IEnumerable<Signal>> AnalyzeAsync(...)
    {
        var chunks = await ChunkDocumentAsync(path);

        ctx.SetCached("chunks", chunks);  // Share with other waves

        return new[]
        {
            new Signal
            {
                Key = "document.chunked",
                Value = chunks.Count,
                Source = Name
            }
        };
    }
}

Stadium Einbetten von (ausgelöst durch Dokument Ausblenden von .Ausgedrückt aus )

public class EmbeddingWave : ConfiguredComponentBase, IContentAnalysisWave
{
    public int Priority => 60;

    public bool ShouldRun(string path, AnalysisContext ctx)
    {
        // Only run if chunking succeeded
        return ctx.GetSignal("document.chunked") != null;
    }

    public async Task<IEnumerable<Signal>> AnalyzeAsync(...)
    {
        var chunks = ctx.GetCached<List<Chunk>>("chunks");
        var embeddings = await GenerateEmbeddingsAsync(chunks);

        ctx.SetCached("embeddings", embeddings);

        return new[]
        {
            new Signal
            {
                Key = "embeddings.generated",
                Value = embeddings.Count,
                Source = Name
            }
        };
    }
}

Stufe 4:-Entitätsextraktion mit Einbettung )-Parallel

public class EntityExtractionWave : ConfiguredComponentBase, IContentAnalysisWave
{
    public int Priority => 60;  // Same as embedding - runs in parallel

    public async Task<IEnumerable<Signal>> AnalyzeAsync(...)
    {
        var chunks = ctx.GetCached<List<Chunk>>("chunks");

        // Use deterministic IDF scoring, not LLM per chunk
        // (See Reduced RAG pattern)
        var entities = await ExtractEntitiesAsync(chunks);

        return new[]
        {
            new Signal
            {
                Key = "entities.extracted",
                Value = entities.Count,
                Confidence = CalculateConfidence(entities),
                Source = Name
            }
        };
    }
}

Stufe Qualitätskontrolle

public class QualityCheckWave : ConfiguredComponentBase, IContentAnalysisWave
{
    public int Priority => 40;  // After embedding + entities

    public async Task<IEnumerable<Signal>> AnalyzeAsync(...)
    {
        var embeddingSignal = ctx.GetSignal("embeddings.generated");
        var entitySignal = ctx.GetSignal("entities.extracted");

        var embeddingCount = (int)embeddingSignal.Value;
        var entityConfidence = entitySignal.Confidence;

        var quality = CalculateQuality(embeddingCount, entityConfidence);

        var signals = new List<Signal>
        {
            new Signal
            {
                Key = "quality.score",
                Value = quality,
                Source = Name
            }
        };

        // Trigger escalation if quality is poor
        if (quality < GetParam<double>("quality_threshold", 0.7))
        {
            signals.Add(new Signal
            {
                Key = "escalation.needed",
                Value = "low_quality_document",
                Source = Name
            });
        }

        return signals;
    }
}

Vorteile dieses Ansatzes

  1. Parallele Ausführung Gleichzeitige Einbettung und Entity-Extraktion
  2. Bedingte Verzweigung Qualitätskontrolle entscheidet, ob eine Eskalation erforderlich ist
  3. Gemeinsamer Kontext Wellen greifen auf Stücke zu, ohne sie explizit zu übergeben.
  4. Leicht zu erweitern Eine neue Welle hinzufügen, ohne bestehende zu ändern
  5. Beobachtbar Jede Stufe sendet Signale aus, die Sie überwachen können

Das ist die Reduzierte RAG Muster in Aktion – Deterministische Extraktion vorn – ,, LLMs nur für die Synthese – MKK2

Anwendungsfall-Stylobot Bot Detection

Stylobot ist ein erweitertes Bot-Detektionssystem, das StyloFlow für mehrstufige Bedrohungsanalysen verwendet... Sehen Sie das komplette Eskalationsbeispiel im Abschnitt : von Fast bis Thorough".

Signal---Driven Orchestration Patterns

Muster-Fan--Aus

Ein Signal löst mehrere Wellen aus

graph LR
    S1[document.uploaded] --> W1[ChunkingWave]
    S1 --> W2[MetadataWave]
    S1 --> W3[LanguageDetectionWave]

    W1 -.signal.-> S2[document.chunked]
    W2 -.signal.-> S3[metadata.extracted]
    W3 -.signal.-> S4[language.detected]

    style S1 stroke:#339af0
    style S2 stroke:#339af0
    style S3 stroke:#339af0
    style S4 stroke:#339af0
    style W1 stroke:#51cf66
    style W2 stroke:#51cf66
    style W3 stroke:#51cf66

Muster-Abhängigkeit

Wellen warten auf frühere Signale

graph LR
    W1[ExtractWave] -.signal.-> S1[text.extracted]
    S1 --> W2[ChunkWave]
    W2 -.signal.-> S2[text.chunked]
    S2 --> W3[EmbedWave]
    W3 -.signal.-> S3[embeddings.generated]

    style S1 stroke:#339af0
    style S2 stroke:#339af0
    style S3 stroke:#339af0
    style W1 stroke:#51cf66
    style W2 stroke:#51cf66
    style W3 stroke:#51cf66

Muster - Bedingte Verzweigung

Unterschiedliche Wellen laufen basierend auf Signalen

graph TD
    W1[DetectorWave] -.signal.-> S1{confidence}

    S1 -->|< 0.4| W2[RejectWave]
    S1 -->|0.4-0.7| W3[EscalateWave]
    S1 -->|> 0.7| W4[AcceptWave]

    W2 -.signal.-> S2[rejected]
    W3 -.signal.-> S3[escalated]
    W4 -.signal.-> S4[accepted]

    style S1 stroke:#ffd43b
    style S2 stroke:#ff6b6b
    style S3 stroke:#ff922b
    style S4 stroke:#51cf66
    style W1 stroke:#339af0
    style W2 stroke:#ff6b6b
    style W3 stroke:#ff922b
    style W4 stroke:#51cf66

Muster der Aggregation

Mehrere Signale lösen eine Welle aus

graph LR
    W1[Wave A] -.signal.-> S1[a.complete]
    W2[Wave B] -.signal.-> S2[b.complete]
    W3[Wave C] -.signal.-> S3[c.complete]

    S1 --> T{All Ready?}
    S2 --> T
    S3 --> T

    T -->|Yes| W4[AggregatorWave]
    W4 -.signal.-> S4[aggregation.complete]

    style S1 stroke:#339af0
    style S2 stroke:#339af0
    style S3 stroke:#339af0
    style S4 stroke:#51cf66
    style T stroke:#ffd43b
    style W4 stroke:#51cf66

Eskalationsmuster

StyloFlow unterstützt Eskalation auf zwei Ebenen

  1. Innergemeinschaftlicher KoordinatorDie Wellen überprüfen das Signalvertrauen und führen bedingt teure Schritte durch.
  2. KoordinatorEskalatorAtm-Routen Signale von schnellen Koordinatoren

Beispiel aus lucidRAG-:-Schnelle Entitätsextraktion läuft zuerst..-Wenn die Qualität... <--- Eskalator... Atom leitet das Dokument zu einem teuren LLM-Verfeinerungskoordinator....-- Das spart Kosten, indem teure LLM fordert hohe --Qualitätsextraktionen vermieden wird.

Minimale Form

Dies ist nicht ein schnelles --Start-Anleitung, es ' ist das kleinste Beispiel, das zeigt, wie das Modell zusammenpasst

Installation

dotnet add package StyloFlow.Complete

Konzeptioneller Einstiegspunkt (MSK)

// 1. Define a wave
public class MyAnalysisWave : IContentAnalysisWave
{
    public string Name => "MyAnalysis";
    public int Priority => 50;
    public bool Enabled { get; set; } = true;

    public bool ShouldRun(string path, AnalysisContext ctx) => true;

    public async Task<IEnumerable<Signal>> AnalyzeAsync(
        string path,
        AnalysisContext ctx,
        CancellationToken ct)
    {
        // Your analysis logic here
        var result = await AnalyzeAsync(path);

        return new[]
        {
            new Signal
            {
                Key = "my.signal",
                Value = result,
                Confidence = 1.0,
                Source = Name
            }
        };
    }
}

// 2. Register waves
var waves = new List<IContentAnalysisWave>
{
    new MyAnalysisWave(),
    new AnotherWave(),
};

// 3. Create coordinator
var coordinator = new WaveCoordinator(
    waves,
    CoordinatorProfile.Default);

// 4. Execute
var context = new AnalysisContext();
var results = await coordinator.ExecuteAsync(filePath, context);

// 5. Read signals
foreach (var signal in context.GetAllSignals())
{
    Console.WriteLine($"{signal.Key}: {signal.Value} ({signal.Confidence})");
}

Mit Manifesten

// Load manifests from directory
var loader = new FileSystemManifestLoader("./manifests");
var manifests = await loader.LoadAllAsync();

// Build waves from manifests
var waves = manifests
    .Where(m => m.Enabled)
    .OrderBy(m => m.Priority)
    .Select(m => WaveFactory.Create(m))
    .ToList();

var coordinator = new WaveCoordinator(waves, profile);

Für vollständige Beispiele siehe: StyloFlow GitHub-Repository.

Workflow-Auffindbarkeit:-YAML-Manifestierungen

Eines der wichtigsten Merkmale von StyloFlow-' ist Workflow-Auffindbarkeit Sie können die gesamte Pipeline nur durch das Lesen der Manifeste verstehen.

Vollständige lucidRAG-Dokumentpipeline

Hier ist die tatsächliche manifestierte Verzeichnisstruktur für lucidRAG-:

manifests/
├── 01-file-type-detector.yaml
├── 02-chunking.yaml
├── 03-embedding.yaml
├── 04-entity-extraction.yaml
├── 05-quality-check.yaml
└── 06-escalation.yaml

01--File, Typ -, Detektor .,yaml, :,

name: FileTypeDetector
priority: 100
enabled: true
description: Detects file type from extension

taxonomy:
  kind: sensor
  determinism: deterministic
  persistence: ephemeral

triggers:
  requires:
    - signal: document.uploaded
      condition: exists

emits:
  on_start:
    - file.detection.started
  on_complete:
    - key: file.extension
      type: string
      confidence_range: [1.0, 1.0]
    - key: file.mime_type
      type: string
      confidence_range: [1.0, 1.0]

lane:
  name: fast
  max_concurrency: 16

budget:
  max_duration: 10ms

]02--Cunking, .-yaml, :-cunking

name: ChunkingWave
priority: 80
enabled: true
description: Splits documents into semantic chunks

taxonomy:
  kind: extractor
  determinism: deterministic
  persistence: ephemeral

input:
  accepts:
    - document.pdf
    - document.docx
    - document.markdown
  required_signals:
    - file.extension

triggers:
  requires:
    - signal: file.extension
      condition: in
      value: [".pdf", ".docx", ".md", ".txt"]

emits:
  on_complete:
    - key: document.chunked
      type: integer
      confidence_range: [1.0, 1.0]
    - key: chunks.cached
      type: boolean

lane:
  name: normal
  max_concurrency: 8

budget:
  max_duration: 30s

defaults:
  chunking:
    max_chunk_size: 512
    overlap: 50
    respect_boundaries: true

03--Einbettung .-Yaml-:-

name: EmbeddingWave
priority: 60
ires:
    - signal: file.extension
      condition: in
      value: [".pdf", ".docx", ".md", ".txt"]

emits:
  on_complete:
    - key: document.chunked
      type: integer
      confidence_range: [1.0, 1.0]
    - key: chunks.cached
      type: boolean

lane:
  name: normal
  max_concurrency: 8

budget:
  max_duration: 30s

defaults:
  chunking:
    max_chunk_size: 512
    overlap: 50
    respect_boundaries: true

03--Einbettung .-Yaml-:-

name: EmbeddingWave
priority: 60
enabled: true
description: Generates ONNX embeddings for chunks

taxonomy:
  kind: embedder
  determinism: deterministic
  persistence: cached

input:
  required_signals:
    - document.chunked
    - chunks.cached

triggers:
  requires:
    - signal: document.chunked
      condition: ">"
      value: 0

emits:
  on_complete:
    - key: embeddings.generated
      type: integer
      confidence_range: [1.0, 1.0]

lane:
  name: normal
  max_concurrency: 4

budget:
  max_duration: 2m
  max_cost: 0.0  # Local ONNX model

defaults:
  embedding:
    model: all-MiniLM-L6-v2
    batch_size: 32

,04--Entität , --Extraktion , .-Yaml , :-Extrakt

name: EntityExtractionWave
priority: 60  # Same as embedding - runs in parallel
enabled: true
description: Extracts entities using IDF scoring

taxonomy:
  kind: extractor
  determinism: deterministic
  persistence: persisted

input:
  required_signals:
    - document.chunked

triggers:
  requires:
    - signal: document.chunked
      condition: ">"
      value: 0

emits:
  on_complete:
    - key: entities.extracted
      type: integer
      confidence_range: [0.0, 1.0]  # Confidence varies

lane:
  name: normal
  max_concurrency: 8

budget:
  max_duration: 1m

defaults:
  entity:
    min_idf_score: 2.5
    min_frequency: 2
    max_entities: 100

05--Qualität--Prüfung.-yaml-:-

name: QualityCheckWave
priority: 40
enabled: true
description: Validates extraction quality

taxonomy:
  kind: gatekeeper
  determinism: deterministic
  persistence: ephemeral

input:
  required_signals:
    - embeddings.generated
    - entities.extracted

triggers:
  requires:
    - signal: embeddings.generated
      condition: ">"
      value: 0
    - signal: entities.extracted
      condition: exists

emits:
  on_complete:
    - key: quality.score
      type: double
      confidence_range: [0.0, 1.0]

  conditional:
    - key: escalation.needed
      when: quality.score < 0.7

lane:
  name: fast
  max_concurrency: 16

defaults:
  quality:
    min_embeddings: 5
    min_entity_confidence: 0.5
    threshold: 0.7

06--Eskalation.-yaml-:-

name: EscalationWave
priority: 20
enabled: true
description: Improves low-quality extractions using LLM

taxonomy:
  kind: proposer
  determinism: probabilistic
  persistence: persisted

input:
  required_signals:
    - escalation.needed

triggers:
  requires:
    - signal: escalation.needed
      condition: exists
  skip_when:
    - signal: budget.exhausted

emits:
  on_complete:
    - key: escalation.complete
      type: boolean
    - key: entities.improved
      type: integer
      confidence_range: [0.7, 1.0]

lane:
  name: llm
  max_concurrency: 2  # Expensive

budget:
  max_duration: 30s
  max_tokens: 4000
  max_cost: 0.05

defaults:
  llm:
    model: gpt-4o-mini
    temperature: 0.1
    prompt_template: entity_extraction

Vorteile von deklarativen Manifesten

Betrachten Sie diese Dateien Sie wissen sofort

  1. Ausführungsauftrag Prioritätszahlen der (100, → und 80, →, MSC5, MCSK6 und 40, → und MSC9
  2. Abhängigkeiten Welche Signale jede Welle benötigt, um zu laufen
  3. Parallelität Einbetten von (60) und EntityExtraction laufen zusammen
  4. Ressourcengrenzen Verschiedene Fahrspuren und Konkurrenz pro Welle
  5. Bedingte Logik Die Eskalation läuft nur dann, wenn die Qualität
  6. Kostengrenzen Eskalation hat Token und Kostengrenzen

Keine Code-Lesung erforderlich Der Workflow ist selbst, -, documenting,.,

Code: --basierte Atome, die in Manifesten aufgeführt sind

Während die obigen Beispiele zeigen voll deklarative YAML-,-Wellen können auch auf der Grundlage von --Atomen referenziert in Manifesten

name: CustomAnalyzer
priority: 50
enabled: true
description: Custom analysis logic

# Reference a code-based atom implementation
implementation:
  assembly: MyProject.Analyzers
  type: MyProject.Analyzers.CustomAnalyzerWave
  method: AnalyzeAsync

# The manifest still declares the contract
taxonomy:
  kind: analyzer
  determinism: probabilistic

triggers:
  requires:
    - signal: data.ready

emits:
  on_complete:
    - key: analysis.complete
      confidence_range: [0.0, 1.0]

lane:
  name: normal
  max_concurrency: 4

# Configuration values passed to the atom
defaults:
  threshold: 0.75
  max_iterations: 10

Die Implementierung von C.M.S.K.

public class CustomAnalyzerWave : ConfiguredComponentBase, IContentAnalysisWave
{
    public async Task<IEnumerable<Signal>> AnalyzeAsync(
        string path,
        AnalysisContext ctx,
        CancellationToken ct)
    {
        // Access manifest config
        var threshold = GetParam<double>("threshold", 0.75);
        var maxIterations = GetParam<int>("max_iterations", 10);

        // Custom logic here
        var result = await PerformComplexAnalysis(path, threshold, maxIterations);

        return new[]
        {
            new Signal
            {
                Key = "analysis.complete",
                Value = result.Score,
                Confidence = result.Confidence,
                Source = Name
            }
        };
    }
}

Vorteile

  • Manifest erklärt den Vertrag --Triggersignale ,-Budgetspuren
  • Code bietet Implementierung - Komplexe Logik - Externe Abhängigkeiten
  • Konfiguration fließt durch Manifest Standardeinstellungen überschreiben Code-Standards
  • Prüfung der Unabhängigkeit Testcode ohne Manifeste, validieren Manifeste ohne laufenden Code

Dieser hybride Ansatz gibt Ihnen deklarative Workflow-Entdeckung, während Sie komplexe Logik in wartungsfähig C.#....

Pipeline-Visualisierung aus Manifesten

Die manifestierte Struktur macht es trivial, um Visualisierungen zu generieren

graph TD
    DOC[document.uploaded] --> FT[FileTypeDetector<br/>Priority: 100<br/>Lane: fast]
    FT --> EXT[file.extension]

    EXT --> CH[ChunkingWave<br/>Priority: 80<br/>Lane: normal]
    CH --> CHUNKED[document.chunked]

    CHUNKED --> EMB[EmbeddingWave<br/>Priority: 60<br/>Lane: normal]
    CHUNKED --> ENT[EntityExtractionWave<br/>Priority: 60<br/>Lane: normal]

    EMB --> EMBGEN[embeddings.generated]
    ENT --> ENTEX[entities.extracted]

    EMBGEN --> QC[QualityCheckWave<br/>Priority: 40<br/>Lane: fast]
    ENTEX --> QC

    QC --> QSCORE[quality.score]
    QC -.conditional.-> ESC_NEED[escalation.needed]

    ESC_NEED -.-> ESC[EscalationWave<br/>Priority: 20<br/>Lane: llm]
    ESC --> ESC_DONE[escalation.complete]

    style DOC stroke:#339af0
    style FT stroke:#51cf66
    style CH stroke:#51cf66
    style EMB stroke:#51cf66
    style ENT stroke:#51cf66
    style QC stroke:#ffd43b
    style ESC stroke:#ff922b

Dieses Diagramm wurde programmatisch aus dem YAML manifestiert erzeugt.

Neben der Verwendung von Code-LLMs für den StyloFlow-Weg

Eine unerwartete Eigenschaft von StyloFlow ist, dass es ein System erstellt LLMs können sicher denken.

Die meisten Versuche, LLMs für Debugging oder Orchestrierung zu verwenden scheitern, weil das System sie fallen gelassen ist undurchsichtig.

  • Staat ist implizit
  • Kontrollfluss ist im Code vergraben
  • Entscheidungen werden als Nebenwirkungen kodiert
  • Logs sind narrativ, nicht kausal

StyloFloFlow tut das Gegenteil... es entlarvt explizite, unveränderliche Fakten über das, was geschah, wenn und mit welchem Vertrauen

Das macht Code LLMs nicht als Schauspieler wirklich nützlich, sondern als Analysten.

LLMs Grund über nicht das System-, innen es

In StyloFlow, einem LLM, nie

  • Auslösung
  • Ergibt Signale
  • Zustand der Mutationen
  • Eigene Entscheidungen

Stattdessen wird ein SignalSink Ansicht und stellte Fragen wie:

  • Warum eskalierte diese Welle?
  • Dieses Signal bewirkte, dass dieser Pfad lief.
  • Wo ist das Vertrauen am niedrigsten?
  • Das vorgelagerte Signal widerspricht diesem Ergebnis.
  • Was würde passieren, wenn diese Schwelle erhöht würde?

Beispieleingabe zu einem Code LLM-:

{
  "operation": "doc-123",
  "signals": [
    { "key": "document.chunked", "value": 12, "confidence": 1.0, "source": "ChunkingWave" },
    { "key": "entities.extracted", "value": 4, "confidence": 0.42, "source": "EntityWave" },
    { "key": "quality.score", "value": 0.39, "source": "QualityCheckWave" },
    { "key": "escalation.needed", "source": "QualityCheckWave" }
  ]
}

Dass ,''s nicht ein Protokollstrom ,. ,das ,mesK2's a Schlussfolgerungsstoff.

Ein Code LLM kann jetzt

  • Erklären Sie die Kausalität, da die Eskalation ausgelöst wurde, weil die Qualität
  • Identifizieren Sie schwache Verbindungen - (" ,entity Extraktion Vertrauen dominiert Ausfall-") .
  • Schlagen Sie Abschwächungen vor, einen anderen Extraktor vor dem Eskalieren zu laufen.
  • Vorgeschlagene Konfigurationsänderungen Unteres Entity Min.-.IDF für PDFs

Alle ohne vertraut zu werden tun alles, was Sie brauchen

Debugging wird inspection.,-nicht reenactment

Traditionelles Debuggen von "-LLM - versucht, die Welt wiederzuspielen

Hier ist der Code und einige Protokolle, was schief gegangen ist.

StyloFlow-Debugging ist einfacher

Hier ist der genaue Zustand, den das System beobachtet hat.

Weil Signale unveränderlich sind und im Besitz von , sind, müssen Sie nicht re-- run alles, was Sie tun müssen, um intent rekonstruieren. . Sie brauchen die LLM zu erraten.

Die LLM Gründe über Fakten, denen Sie bereits vertrauen

Warum dies nicht in Agent Theater verwandelt

Dies funktioniert nur wegen der strengen Grenzen.

  • LLMs können Analyse Signale
  • Deterministischer Code Rechtsakte auf Signalen
  • Nur Manifeste und Code-Änderungsverhalten

Es gibt keine Rückkopplungsschleife, in der die LLM "-Dezides... den nächsten Schritt... .... höchstens Erklärungen oder Konfigurationsvorschläge vorschlägt, dass eine menschliche Deterministenpolitik... )... später gelten kann.

Dass Asymmetrie absichtlich ist

Eine Seite ,--Effekt , : , zukünftige Selbsteinstimmung , ohne Autonomie

Sobald signals-,-Konfidenz, , und Ergebnisse sind explizit kann Spätere Pressemitteilungen

  • Mine historische Signalspuren
  • Bewertung, welche Eskalationen geholfen haben
  • Abschaltschwellen offline
  • Wellen zwischen den Bahnen fördern oder degradieren

Nichts davon erfordert es, dass ein LLM das System ausführen lässt.

Die LLM wird ein DiagnoselinseNicht eine Kontrollfläche

Warum das so wichtig ist

StyloFlow doesn's'-t nur probabilistische Systeme sicher machen

Es macht sie lesbar Zu den Menschen zu den Tests und zu den LLMs, ohne die Kontrolle aufzugeben

Das ist der Unterschied zwischen

  • LLMs, die Ihr System ausführen
  • und verstehen Sie Ihr System.

Nur eine dieser Skalen

Emergente Eigenschaften

Erklärungszusammensetzung

Komponenten deklarieren ihre Kontrakte (-Trigger,-Signale,-Budget),-Nicht ihre Abhängigkeiten.-Das System stellt Ausführungsauftrag vor.-Dies ist ein Feature '-Dies passiert, wenn Sie Signale zuerst--Klasse machen..-

Standardmäßig beobachtbar

Jede Aktion ist ein Signal ,. , Sie tun ,' , nicht hinzufügen Beobachtbarkeit , - , es inhärent ' , Volle Ausführung trace , , , Konfidenz-Tracking ., , Eskalationspfade , und Budgetverbrauch fallen natürlich heraus , . ,

Anpassende Ausführung

Vertrauen Punkte Antrieb Verzweigung ohne explizite Routing-Logik überspringen teure Stufen, wenn unnötig Eskalation ,, wenn unsicher,, vorzeitig abbrechen hoch-,Vertrauensausfälle ., Der Steuerungsfluss entsteht aus Signalmustern

Testbarkeit ohne spöttische Rahmen

Mock-Signale, nicht Komponenten, nicht Bestandteile, nicht :

var context = new AnalysisContext();
context.AddSignal(new Signal
{
    Key = "document.chunked",
    Value = 10,
    Confidence = 1.0,
    Source = "Test"
});

var wave = new EmbeddingWave();
var results = await wave.AnalyzeAsync(path, context, ct);

Assert.Single(results);
Assert.Equal("embeddings.generated", results.First().Key);

Inkrementale Komplexität

Einfach starten

var coordinator = new EphemeralWorkCoordinator<Job>(ProcessAsync);

Bei Bedarf Signale hinzufügen

new EphemeralOptions { Signals = signalSink }

Wellen für Multi---Stadium hinzufügen

var waveCoordinator = new WaveCoordinator(waves, profile);

Manifeste für deklarative Konfiguration hinzufügen

name: MyWave
triggers: [...]
emits: [...]

Vollständige Pipeline, MSK, lucidRAG-Dokumentaufnahme

Hier ist das komplette LucidRAG Pipeline auf einen Blick sehen Sie die detaillierten Code-Beispiele im Abschnitt "

  1. Hochladen → document.uploaded Signal
  2. DateitypWave erkennt PDF./.DOCX./.Markdown. file.extension Signal
  3. GewinnungWave zieht Text und Struktur text.extracted Signal
  4. VerdunklungWave zerteilt sich semantisch document.chunked Signal
  5. EinbettenWave erzeugt Vektoren embeddings.generated Signal
  6. UnternehmenWave extrahiert Entitäten (-parallel-)-→- entities.extracted Signal
  7. QualitätWave prüft die Vollständigkeit quality.score Signal
  8. EskalationWave Bedingt, wenn die Qualität escalation.complete Signal
  9. SpeicherWave fortbesteht bei Qdrant -+-PostgreSQL- -→- storage.complete Signal

Die Benutzeroberfläche abonniert die SignalSink für echte .- ?time Fortschrittsaktualisierungen ?( ?push pattern ? ): ?

// Subscribe to sink for push notifications
signalSink.Subscribe(signal => {
    if (signal.Key.StartsWith("document."))
    {
        await _hub.Clients.User(userId)
            .SendAsync("DocumentProgress", new
            {
                stage = signal.Key,
                progress = CalculateProgress(signal),
                operationId = signal.OperationId
            });
    }
});

Oder verwenden Sie das Pull-Muster, wenn Sie es bevorzugen

// Query SignalSink for document progress (pull pattern)
var documentSignals = signalSink.GetSignals()
    .Where(s => s.Key.StartsWith("document.") &&
                s.Timestamp > lastCheck);

foreach (var signal in documentSignals)
{
    UpdateProgressUI(signal);
}

Wesentlicher Punkt Sie abonnieren die SINK ( , die alle Atome betrachtet , nicht zu einzelnen Operationen , . , Atoms eigene Signale , das Waschbecken bietet Push- , ( , Subscribe , und ziehen Sie ( query ,) , Zugang zu ihnen .

Dies ist, wie LucidRAG Verarbeitung von Dokumenten, Daten und Bildern durch ein einheitliches Signal, - driven Pipeline DocSummarizer, DatenZusammenfassungL 347 vom 20.12.2013, S. 671. ImageSummarizer unter einer Orchestrierungsschicht

Vollständige Pipeline-Erkennung für Stylobot Bot

Hier ist das komplette Stylobot Pipeline auf einen Blick sehen Sie ausführlichen Code in ".Eskalation:. Von schnell bis tiefgründig"):.

  1. IpReputationWave überprüft IP gegen bekannte Bot-Listen bot.detected Signal mit Vertrauen
  2. VerhaltenAnalyseWave Vorbehaltlich, wenn 0.4... das Vertrauen von <... das Nutzer-Agenten- und Klickmuster analysiert. bot.detected Signal
  3. LlmBotAnalyseWave Bedingt, wenn immer noch mehrdeutig, verwendet )-LLM für die Konversationsanalyse. bot.detected Signal

Der entscheidende Vorteil der Eskalation auf Basis des Vertrauens

// ❌ Traditional: Every request gets expensive analysis
var reputation = await CheckIpAsync(ip);
var behavior = await AnalyzeBehaviorAsync(session);  // Even if IP is known bad
var llmScore = await LlmAnalysisAsync(conversation);  // Always expensive

// ✅ StyloFlow: Waves run based on confidence signals
// BehaviorAnalysis only runs if confidence is ambiguous (0.4-0.7)
// LLM analysis only runs if still unsure after behavior check

Kostenaufschlüsselung IP-Kontrollkosten und Laufzeiten von 100% der Zeit.] Behaviorale Analyseläufe von 30%] ( ambiguous cases – LLM-Analyseläufe von5%( immer noch mehrdeutig). Gesamtkosten pro Anfrage:" $0.0001 vs naive "-LLM alles, bei $0.002 Einsparungen bei (20x

Vergleich mit anderen Workflow-Engines

Funktion , StyloFlow, Temporaler Luftstrom Schrittfunktionen ,
Koordinierung Signal-, Signal- und Datenübertragungsgeräte auf der Basis von , RPC, -, DAG, MSC5, State Machine
Erklärung ✅YAML manifestiert YAml-Code, zuerst YALM-DAGs, dann ✅JSON-/YAMT-MSC10
Bedingung Signalauslöser Auszugsbedingungen MSSK4Ausgangszustand MSKK5Ausstiegszustand Austrittsstatus MSKS7Auswahlzustand
Eskalation ✅Ausgebautes -Ausgestelltes Handbuch Ausgeführtes Manual Ausgebrachtes Manuelles Ausgewähltes Handbuch
Beobachtungsfähigkeit ✅, Signalspuren , ✅, Workflow-Geschichte , ✅, Auftragsprotokolle , MSC7, Ausführungshistorie ,
Haushaltskontrolle -M✅-Token-/-Kostenlimite Manual- -MNSK6-MUSK7-MKSK8-Handbuch
Lokale Ausführung Benötigt Cluster Benötigte Cluster Befordert Cluster Befragte Cluster Bezeichnet Benötigt nur AWS Berechnet
Fahrspuren für die Übereinstimmung Weitere Informationen: http://europa.eu.int/comm/index_de.htm

Wo dieses Modell natürlich passt

  • AII-/-ML-Pipelines mit Eskalation (-Scheap-Verteuerung )-
  • Dokumentenverarbeitung mit bedingten Stufen
  • Bot-Detektion mit mehrstufiger Analyse
  • RAG-Systeme mit hybrider Suche
  • Jeder Workflow, bei dem Komponenten auf Vertrauenswerte reagieren

Wo es nicht mehr ', nicht weniger ( und nicht weniger ', nicht mehr ):

  • Einfache sequentielle Jobs -(-ephemere Koordinator ist genug - )-
  • Reif verteilte Workflows über Rechenzentren
  • Lange, laufende Arbeitsabläufe mit menschlichen Zulassungen (Temporal/ Airflow)
  • Workflow-Versionierung mit Schema-Migration

Wo dieses Modell hinführt

Dies sind natürliche Erweiterungen des Modells... nicht Verpflichtungen zu einer spezifischen Implementierung...

Da sich die Semantik durch lucidRAG und Stylobot-Entwicklung stabilisiert, werden diese Muster praktikabel.

Aus Signalen lernen

Verfolgen Sie, welche Eskalationswege am besten funktionieren.

// Did the LLM escalation improve accuracy?
// Learn to skip it if behavioral analysis is sufficient

Kostenoptimierung

Automatische Fahrspurzuweisung basierend auf historischer Leistung

// If a "slow" wave completes quickly, promote to "normal"

Signalwiedergabe

Debuggen durch Wiedergabe von Signalsequenzen

var replay = SignalReplay.FromFile("trace.jsonl");
await coordinator.ReplayAsync(replay);

Maschinenkoordination

Verteilen Sie Fahrspuren über Maschinen, während die Signale zentralisiert bleiben

Warum Signale wichtig sind

Der Kern der Erkenntnis ist: in KI-Systemen – jede Komponente hat Vertrauen.

Traditionelle Workflows gehen davon aus, dass die KI-Workflows Erfolg haben müssen

  • Vertrauensnoten Wie sicher sind wir?
  • Bedingte Ausführung Überspringen Sie teure Stufen, wenn selbstbewusst
  • Eskalation Versuchen Sie mehr, wenn unsicher
  • Zusammenrechnung Kombination mehrerer Signale

Signale stellen diese natürlich zur Verfügung

// Multiple detectors vote
var signals = context.GetSignals("bot.detected");

// Aggregate by confidence
var verdict = signals
    .OrderByDescending(s => s.Confidence)
    .First();

// Or majority vote
var isBot = signals
    .Count(s => (bool)s.Value) > signals.Count() / 2;

// Or weighted average
var score = signals
    .Sum(s => (bool)s.Value ? s.Confidence : -s.Confidence)
    / signals.Count();

Deshalb funktioniert StyloFlow gut für Reduzierte RAG Jede Extraktionsstufe erzeugt einen Konfidenzwert und Synthese geschieht nur dann, wenn das Vertrauen hoch genug ist.

Zusammenfassung

Das Ausführungsmodell

  • Signale als erste Fakten der --Klasse nicht Ereignisse oder Nachrichten
  • Vertrauen Punkte Antriebssteuerung Fluss
  • Wellen koordinieren über Trigger keine direkten Anrufe
  • Lanes erzwingen Ressourcengrenzen
  • Aufbauend auf meistlucid-.-ephemer

Warum Signale von Bedeutung sind

  1. Stabile Verteilungsgrenze ,- , Serialisierbar , , , timestamped , , , integriert
  2. Angabe der Zusammensetzung Die Manifeste definieren Kontrakte, Laufzeiten und Ausführung
  3. Adaptives Routing Vertrauen ermöglicht Eskalation ohne hardcodierte Verzweigung
  4. Inhärente Beobachtungsfähigkeit Jede Aktion ist bereits ein Signal
  5. Freier Besitz Externe Immutierbarkeit verhindert Wirkung , - ,at ,- ,a ,- Entfernung

Arbeitsumsetzungen

  • LucidRAG Beschreibung des Dokuments Q.M.S.K.A mit bedingter Entitätsextraktion
  • Stylobot Bot-Detektion mit Konfidenzmittel- driven Eskalation . .( .IP Verhalten . → . LLM .
  • Reduzierte RAG Deterministische Extraktion der gebundenen LLM

Verwandte Artikel

Quelle: : GitHub - MSK - StyloFlow

Der Kern der Erkenntnis

Traditionelle Workflow-Engines bitten Sie zu deklarieren was als nächstes passiertDieses Modell bittet Komponenten zu deklarieren was sie produzieren und was sie brauchenDie Signale können dann die Ausführung koordinieren.

Die Schlüsselverschiebung Signale Entkoppelung ,-Vertrauensführer,-Schiene schützen.

Hier geht es um die Auswahl von StyloFlow über Temporale oder Airflow.Diese lösen verschiedene Probleme.(Belastbare Ausführung.,Bedingte Workflow-Versionierung.MSC4Beseitigte Koordination über Rechenzentren.MSSK5Berühren Sie ein anderes Orchestrierungsmodell, bei dem der Steuerungsfluss aus Signalmustern entsteht, anstatt explizit programmiert zu werden.

Wenn du die AI-/ ML Pipelines baust, bei denen die :

  • Vertrauen zählt nicht nur Erfolg
  • Eskalation ist strukturell nicht ein spezieller Fall.
  • Komponenten sollten sich kennen
  • Die Beobachtbarkeit sollte inhärent sein.

Diese Ausführung Semantik könnte dann passen, wie Sie denken

Das ephemere Bibliothek ist die stabile foundation?.-StyloFlow fügt das Signal hinzu.--gesteuerte Orchestrierungsschicht oben.MSC2-T Beide entwickeln sich durch den realen Einsatz in lucidRAG und Stylobot...

Für Fragen oder Rückmeldungen siehe das GitHub-Repository.

Finding related posts...
logo

© 2026 Scott Galloway — Unlicense — All content and source code on this site is free to use, copy, modify, and sell.