# स्टिलियोफ्लो: संकीर्ण अस्पष्ट सिग्नल-प्रचालित कार्यप्रवाह

<!--category-- Architecture, AI, Workflows, C#, Signals, RAG -->
<datetime class="hidden">2026-01-11T14:00</datetime>

मैंने StyloFlow बनाया क्योंकि मैं लिख रहा था [एक ही नमूना बार-बार](https://www.mostlylucid.net/blog/reduced-rag)components that react to what happened before, emit confidence scores, and sometimes need to escalate to more expensive analysis. Existing workflow engines wanted me to think in terms of DAGs or state machines

> नोट: StyloFlow अभी भी एक तैयार उत्पाद नहीं है ; क्योंकि मैं lucidRAG और StyloBot बनाता हूँ IM SK2 मैं अनुपस्थित सुविधाओं को जोड़ रहा हूँ और दोनों StyloBllow और अल्पकालिक पर API को पल्सिंग करता हूँ . यहMSSK4 अभी भी सक्रिय विकास में है।

**स्टिलियोफ्लो एक संकेत---प्रचालित वाद्य मंडली लाइब्रेरी है जो मेल खाता है [मेरा विचार](https://www.mostlylucid.net/blog/thinking-in-systems) के बारे में[ एआई पाइपलाइन](https://www.mostlylucid.net/blog/tencommandments):** components declare what they produce and what they need, confidence scores guide execution, and cheap operations run first with escalation to expensive ones only when needed

यह मूल संरचना ऊर्जा है **[*सुदृढ़*आरएजी](https://www.mostlylucid.net/blog/lucidrag-multi-document-rag-web-app)** - एक क्रॉस-मोडल ग्राफ RAG उपकरण जो संयोजन करता है [डॉक-सममैरिजर](/blog/building-a-document-summarizer-with-rag) दस्तावेज [डेटा-सममारीजरName](/blog/datasummarizer-how-it-works) (संरचनात्मक डेटा [ImageSummarizerComment](/blog/constrained-fuzzy-image-intelligence) एक एकीकृत प्रश्न में (images)के साथ ज्ञान ग्राफ विजुअलाइज़ेशन के साथ संवर्धन प्रणाली [स्टाइलोबोट](https://www.stylobot.net) (एक उन्नत बॉट संरक्षण प्रणाली) और कार्यान्वित करता है [कम RAG](/blog/reduced-rag) पैटर्न

![lucidRAG इंटरफेस](lucidrag_proto.png?width=500)

**स्रोत:** [GitHub - StyloFlow](https://github.com/scottgal/styloflow)

[TOC]

---


## यह क्या है

**स्टिलियोफ्लो एक संकेत के कार्यशील प्रारूप है** API और आकार विकसित होगा जैसे कि मैं lucidRAG और Stylobot बनाता हूँ, लेकिन यहाँ वर्णन किया गया निष्पादन अर्थ और पैटर्न बिन्दु के रूप में संकेतों के रूप मे पहला है।

यह एक नया DSL या कार्यप्रवाह भाषा नहीं है **निष्पादन अर्थशास्त्र** संकेतों के चारों ओर बनाया गया।

---


## पारंपरिक कार्यप्रणाली के साथ समस्या

यहाँ क्या अधिकतर कार्यप्रवाह इंजनों की तरह दिखता है

```csharp
// ❌ 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);
}
```

यह तब तक काम करता है जब तक

- आप साधारण क्वेरी के लिए अस्तित्व निष्कर्षण छोड़ना चाहते हैं
- आपको समांतर में निष्कर्षण और एम्बेडिंग चलाने की जरूरत है
- आप एक बेहतर मॉडल पर विश्वास के आधार पर बढ़ना चाहते हैं
- आपको मौजूदा कोड को छुए बिना एक नया प्रक्रमण चरण जोड़ने की जरूरत है

आप या तो के साथ समाप्त हो जाता है

1. **कठोर पाइपलाइन** जो ' अनुकूल नहीं कर सकता है
2. **भारी यदि** रूटिंग के लिए पेड़
3. **ईश्वर वर्ग** जो सब कुछ जानते हैं

## फाउंडेशन

स्टिलियोफ्लो पर निर्माण करता है [mostlylucid.](/blog/ephemeral-execution-library) - सीमाबद्ध के लिए एक लाइब्रेरी

What ephemeral provides की त्वरित सारांश

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

**अल्पावधि से मुख्य लाभ**

- बार्ड समवर्तन (नहीं रनवे मेमोरी
- [एलआरयू निष्कासन](/blog/learning-lrus-when-capacity-makes-systems-better) पुराने ऑपरेशनों का
- cross-component coordination के लिए संकेत प्रकाशन
- पूर्वानुभूति से बाहर निकाले जाने की रोकथाम के लिए ऑपरेशन पिनिंग

अधिक जानकारी के लिए-, देखें [आग और Don't Quite Forget](/blog/fire-and-dont-quite-forget-ephemeral-execution).

---


## क्या यह मॉडल सक्षम करता है

इस वादन मॉडल के साथ अल्पकालिक विस्तार करता है

1. **YAML-driven अवयव manifests** - घोषणात्मक कॉन्फ़िगरेशन
2. **संकेत-- आधारित ट्रिगर** - घटक जब संकेत प्रकट होते हैं चलाएँ
3. **तरंग समन्वय** - प्राथमिकता-आधारित निष्पादन concurrency लेनों के साथ
4. **उत्तेजना नमूने** - महंगे विश्लेषण की आवश्यकता तक स्थगित करें
5. **इकाई संविदाएं** - प्रकार
6. **बजट प्रबंधन** - टोकन सीमाएं

यहाँ मुख्य वास्तुकला परिवर्तन है

```mermaid
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
```

घटक एक-दूसरे को कभी नहीं बुलाते

---


## कोर संकल्पना: संकेत और स्वामित्व

**संकेत क्या हुआ के बारे में तथ्य हैं**कमांड या घटना नहीं हैं।

```csharp
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; }
}
```

**महत्वपूर्ण वास्तुकला बिन्दु**

**सिग्नल सिंक** सभी आपरेशनों में सभी समन्वयकों पर एक क्वेरी योग्य दृश्य उपलब्ध कराता है जो इसे साझा करता है

```csharp
// 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
```

**सिग्नल सिंक दो समन्वय पैटर्न प्रदान करता है**

**आधार पर 1. Push**

```csharp
// 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**

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

**यह क्यों महत्वपूर्ण है**

- **सिर्फ पढ़ने के लिए दृश्य** - सिग्नल सिंक संकेतों को बदल नहीं सकता है
- **संकेत जारी हैं** - संकेतों को तब तक नजर में रखा जाता है जब तक कि उनकी कार्रवाई समन्वयक से बाहर नहीं जाती
- **संकेत समन्वयन हैं, नहीं परिवहन** - संकेतों के पास कुंजियाँ होती हैं
- **समन्वयक स्वतंत्रता** - कई समन्वयक एक सिंक साझा कर सकते हैं
- **थ्रेड** - लॉक
- **दोनों धकेलना और खींचना** निष्क्रिय के लिए - सदस्यता लें
- **ऑपरेशन सहसंबंध** - प्रत्येक संकेत में समन्वयकों के बीच ट्रैसिंग हेतु ऑपरेटिंग आईडी शामिल है
- **पैटर्न मिलान** - सही मिलान द्वारा क्वेरी

**प्रमुख डिजाइन सिद्धांत** बड़े डेटा को भंडारित करें (documents, imagesM SK2 vectorsMSC3 in caches or databases . Signals only carry references like `"cache://doc-123"` या संचालन कुंजियाँ

उदाहरण समन्वय

```csharp
// 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);
    }
});
```

**उत्तेजना दो स्तरों पर होती है**

1. **एक समन्वयक के भीतर** - तरंग संकेत विश्वास की जांच करते हैं और शर्त पर महंगे विश्लेषण चलाएँ
2. **समन्वयकों के बीच** - EscalatorAtom रूटों से तेजी से समन्वयक से संकेत करता है

```csharp
// 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
}
```

कई समन्वयक स्वतंत्र रूप से चलाते हैं

इसके पीछे सिद्धांत के लिए देखें [प्रतिबंधित अस्पष्ट संदर्भ खींचना](/blog/constrained-fuzzy-context-dragging).

### सिग्नल रेफरेंस लाते हैं

**महत्वपूर्ण:** संकेत समन्वय घटनाएँ हैं।

```csharp
// ❌ 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);
    }
}
```

**सर्वोत्तम प्रथाएं**

- अल्पावधि डेटा के लिए कैश (inM SK1memory या वितरित) का उपयोग करें
- स्थायी डेटा के लिए डाटाबेस का उपयोग करें
- बड़े फ़ाइलों के लिए ब्लब भंडारण का उपयोग करें
- संकेत यूआरआई `"cache://key"`, `"blob://container/file"`, `"db://table/id"`
- संकेतों को हल्का रखें - सिर्फ कुंजियाँ | , | विश्वास प्राप्तियां |,

---


## कोर संकल्पना

**घोषणा पत्रों में संविदाएं घोषित की जाती हैं।** कार्यान्वयन से अलग. यह पृथक्ता मौजूद है इसलिए आप कोड पढ़ने के बिना कार्यप्रवाह को समझ सकते हैं

```yaml
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
```

**लाभ**

1. **रनटाइम पुनः कॉन्फ़िगरेशन** - पुनर्संकलन किए बिना प्राथमिकता बदलें
2. **वातावरण अधिरोहित करता है** अनुप्रयोग से अधिरोहित करें
3. **स्पष्ट संविदाएं** - देखो क्या संकेत क्या ट्रिगर करते हैं
4. **स्वयं** - घोषणा स्पेक्ट है

### दृश्य कार्यप्रवाह बिल्डर

जबकि आप YAML मैनिस्ट्रेट हाथ से लिख सकते हैं, स्टिलियोफ्लो में एक दृश्य कार्यप्रवाह बिल्डर शामिल है जो आपको मॉड्यूलर का उपयोग करके संकेत डिजाइन करता है

![स्टिलियोफ्लो कार्यप्रवाह बिल्डर](styloflow_ui.png?width=800)

यूआई प्रदान करता है

- **ड्रॉप अवयव** वर्गीकरण से (
- **सिग्नल तार पैचिंग** - आउटपुट को इनपुटों से दृश्यात्मक रूप में जोड़ें
- **प्रत्यक्ष प्रदर्शन पूर्वावलोकन** - निर्माण के रूप में उत्पन्न YAML देखें
- **ट्रिगर दृश्यीकरण** - देखो कि कौन से संकेत कौन सी अवयव को ट्रिगर करते हैं
- **लेन आबंटन** - तेजी में घटकों को Drag
- **वास्तविक समय सत्यापन** - अवैध संकेत निर्देशों को तुरंत पकड़ें

यह विभिन्न कार्यप्रवाह आकारों के साथ प्रयोग करने में आसान बनाता है YAML को हाथ से लिखने के बिना जबकि अभी भी आपको उत्पन्न कॉन्फ़िगरेशन पर पूरा नियंत्रण देता है

---


## कोर संकल्पना

एक तरंग एक समायोजित विश्लेषण चरण है **यह अंतरफलक मौजूद है कि हम "के लिए हम चलाना चाहेंगे ?" एक पहला -वर्ग निर्णय बना**, एक क्रियान्वयन विवरण शर्तात्मक तर्क में दफित नहीं है

```csharp
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);
}
```

**सरल तरंग उदाहरण:**

```csharp
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
            }
        };
    }
}
```

**तरंग समन्वय**

 `WaveCoordinator` प्राथमिकता क्रम में तरंग चलाता है

```csharp
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}");
}
```

**प्रतिद्वंद्वी पथ**

विभिन्न समवर्ती सीमाओं के साथ लाइनों में तरंग चलाते हैं

लेन | उद्देश्य | | | प्रतिद्वंद्व ||
|------|---------|-------------|
| `fast` त्वरित जांचें
| `normal` मानक प्रसंस्करण
| `io` | I/O bound (file readsM SK3 API calls
| `llm` | महंगे एलएलएम कॉल्स

इससे किफायती प्रक्रियाओं को रोकने से बचा जाता है

---


## वास्तुकला: यह कैसे एक साथ फिट करता है

यह पूरा चित्र है

```mermaid
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
```

**प्रवाह**

1. इनपुट आ जाता है (HTTP निवेदन, फ़ाइलM SK2 कार्य
2. अल्पकालिक समन्वयक आपरेशन (creates which owns a empty signal list
3. ऑपरेशन अपने स्वामित्व सूची में संकेत जोड़ता है
4. तरंग समन्वयक ट्रिगर अवस्थाओं को जाँचने के लिए SignalSink दृश्य से संकेतों को रीडर करता है
5. वेल्स जिनका ट्रिगर मेल खाता है concurrency लेन के भीतर प्राथमिकता क्रम में चलाएँ
6. प्रत्येक तरंग अपने संचालन में संकेत जोड़ता है
7. तरंग समन्वयक नए समाधान ट्रिगर खोजने के लिए संकेतों को पढ़ने जारी रखता है
8. अंतिम आउटपुट क्वेरी संकेतों को पढ़ने और क्रियाओं का निर्धारण करने के लिए SignalSink

**स्वामित्व मॉडल** प्रत्येक ऑपरेशन /आटोम अपने संकेतों का स्वामित्व रखता है | . | SignalSink सभी ऑपरेशनों में सिर्फ पढ़ने के लिए |- | दृश्य उपलब्ध कराता है

**वर्तमान निष्पादन मॉडल** एकल-प्रक्रिया

**भावी निष्पादन मॉडल** मशीनों के बीच वितरित लेन **संकेत स्थिर सीमा बना रहे हैं** ownership model does not change

प्रक्रिया क्रियान्वयन में सेंटिक्स को वैध करता है

---


## उपयोग केस: lucidRAG दस्तावेज प्रक्रमण

चलो 's कैसे देखो [सुस्पष्टRAG](/blog/lucidrag-multi-document-rag-web-app) StyloFlow का उपयोग करता है

**चरण 1: प्रारंभिक पता लगाना**

```csharp
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"
            }
        };
    }
}
```

**स्टेज 2: ध्वनिबद्धता | ( | फ़ाइल द्वारा ट्रिगर किया गया**

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

**स्टेज 3: सम्मिलन | ( | दस्तावेज़ द्वारा ट्रिगर किया गया**

```csharp
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
            }
        };
    }
}
```

**चरण 4: इकाई निष्कर्षण | ( | एम्बेडिंग के साथ समान |)**

```csharp
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
            }
        };
    }
}
```

**स्टेज 5: गुणवत्ता जांच**

```csharp
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;
    }
}
```

**इस दृष्टिकोण के लाभ**

1. **समांतर निष्पादन** - एम्बेडिंग और एंटिटी एक्सटेक्शन एक साथ चलाएँ
2. **संबन्धित शाखाकरण** - गुणवत्ता जाँच यदि वृद्धि की आवश्यकता है तो निर्णय करता है
3. **साझा संदर्भ** - वेव्स उन्हें स्पष्ट रूप से पास किए बिना chunks एक्सेस करते हैं
4. **विस्तारित करने में आसान** - मौजूदा परिवर्तन किए बिना एक नया तरंग जोड़ें
5. **प्रेक्षणीय** - प्रत्येक चरण आप मॉनिटर कर सकते हैं संकेतों का उत्सर्जन करता है

यह है [कम RAG](/blog/reduced-rag) क्रिया में पैटर्न

---


## केस का उपयोग करें: स्टेलोबोट बोट पता लगाना

[स्टाइलोबोट](https://www.stylobot.net) एक उन्नत बोट पहचान प्रणाली है जो बहुविध खतरे विश्लेषण के लिए StyloFlow का उपयोग करता है

---


## सिग्नल-ड्राइव ऑरेक्ट्रेशन पैटर्न

**पैटर्न 1:**

एक संकेत कई तरंगों को ट्रिगर करता है

```mermaid
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
```

**पैटर्न 2: अनुक्रमिक निर्भरता**

पिछले संकेतों के लिए तरंग प्रतीक्षा करते हैं

```mermaid
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
```

**पैटर्न 3: निबंधित शाखा**

संकेतों के आधार पर विभिन्न तरंग चलाते हैं

```mermaid
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
```

**पैटर्न 4: आकलन**

कई संकेत एक तरंग ट्रिगर करते हैं

```mermaid
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
```

---


## Escalation Patterns

स्टिलोफ्लो दो स्तरों पर वृद्धि को समर्थन करता है

1. **इंट्रा--**: तरंग संकेत विश्वास की जांच करते हैं और शर्त पर महंगे चरण चलाते हैं
2. **अंतर--**: EscalatorAtom रूटों से तेजी से समन्वयक से संकेत

lucidRAG से उदाहरण: सबसे पहले तेजी से इकाई निष्कर्षण चलाता है।

---


## न्यूनतम आकार

> यह एक त्वरित नहीं है।

**संस्थापना**

```bash
dotnet add package StyloFlow.Complete
```

**संकल्पनागत प्रविष्टि बिंदु**

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

**घोषणाओं के साथ**

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

पूर्ण उदाहरणों के लिए, देखें [StyloFlow GitHub रिपोजिटरी](https://github.com/scottgal/styloflow).

---


## कार्यप्रवाह खोजनीयता

StyloFlow के मुख्य विशेषताओं में से एक है **कार्यप्रणाली खोजनीयता** - आप पूरी पाइपलाइन सिर्फ घोषणाओं को पढ़ने के द्वारा समझ सकते हैं

### पूर्ण lucidRAG दस्तावेज़ पाइपलाइन

यहाँ lucidRAG के लिए वास्तविक स्पष्ट निर्देशिका संरचना है

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

**फ़ाइल**

```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-chunking**

```yaml
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-embedding**

```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-embedding**

```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-entityM SK1extraction .yaml:**

```yaml
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
```

**गुणवत्ता**

```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-escalation.yamlM SK2**

```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
```

### घोषणात्मक घोषणापत्रों के लाभ

इन फ़ाइलों को देखकर आप तुरंत जानते हैं

1. **निष्पादन आदेश** प्राथमिकता संख्याएं
2. **निर्भरताएं** - क्या संकेत प्रत्येक तरंग को चलाने के लिए आवश्यक है
3. **समांतरता** - सम्मिलन (60) और इकाई एक्सट्रैक्शन | (60) एक साथ चलाएँ
4. **संसाधन सीमाएँ** - विभिन्न लेन और प्रति तरंग समवर्ती
5. **शर्तिक तर्क** उत्कर्षण तभी चलता है जब गुणवत्ता
6. **लागत सीमाएं** - उत्तेजना चिह्न और लागत सीमा है

**कोई कोड पढ़ने की आवश्यकता नहीं है** कार्यप्रवाह स्वचालित है

### कोड-मानिस में संदर्भित परमाणु

जबकि ऊपर के उदाहरण पूर्ण रूप से घोषणात्मक YAML , तरंग दिखाते हैं भी हो सकता है **कोड-आटोम आधारित** घोषणापत्रों में संदर्भित

```yaml
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
```

क्रियान्वयन

```csharp
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
            }
        };
    }
}
```

**लाभ**

- **घोषणा पत्र संविदा घोषित करता है** - ट्रिगर करता है
- **कोड कार्यान्वयन प्रदान करता है** जटिल तर्क
- **कॉन्फ़िगरेशन प्रवाह के माध्यम से** - प्रदर्शन डिफ़ॉल्ट कोड डिफॉल्ट अधिरोहित करें
- **स्वाधीनता परीक्षण** - मैनिस्ट्रेट के बिना परीक्षण कोड

यह हाइब्रिड दृष्टिकोण आपको घोषणात्मक कार्यप्रणाली खोज प्रदान करता है जबकि जटिल तर्क को बनाए रखने में सक्षम C#.

### घोषणाओं से पाइपलाइन दृश्यीकरण

स्पष्ट संरचना दृश्यीकरण उत्पन्न करने के लिए शून्य बनाता है

```mermaid
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
```

यह चित्र YAML manifests से प्रोग्रामिंग रूप में उत्पन्न किया गया था - कोई मैनुअल ड्राइंग नहीं

---


## एक ओर: कोड एलएलएम्स का प्रयोग करते हुए — स्टिलोफ्लो वे

StyloFlow का एक अप्रत्याशित गुण है कि यह एक सिस्टम बनाता है **एलएलएम सुरक्षित के बारे में तर्क कर सकते हैं**.

डिबगिंग या orchestration के लिए LLMs का उपयोग करने की अधिकतर कोशिशें विफल हैं क्योंकि वे dropped-in सिस्टम अपारदर्शी है

* स्थिति अप्रत्यक्ष है
* नियंत्रण प्रवाह को कोड में दबाया गया है
* निर्णयों को side effects के रूप में एनकोड किया जाता है
* लॉग वर्णनात्मक हैं

StyloFlow विपरीत करता है **अपरिवर्तनीय तथ्य** क्या हुआ जब और किस विश्वास के साथ

जो कोड LLMs को वास्तव में उपयोगी बनाता है — कर्ताओं के रूप में नहीं, बल्कि **विश्लेषक**.

### एलएलएम का कारण *के बारे में* तंत्र *अन्दर* यह

StyloFlow में एक LLM कभी नहीं है

* निष्पादन ट्रिगर करता है
* संकेत भेजता है
* उत्परिवर्तन अवस्था
* अपने निर्णय

इसके बजाय, यह एक दिया जाता है **सिग्नल सिंक दृश्य** और सवाल पूछे जैसे

* एमएसके0Why did this wave escalate?"
* "जिस संकेत ने इस पथ को चलाने के लिए प्रेरित किया है
* "जहां विश्वास सबसे कम है
* "जिस अपस्ट्रीम संकेत इस परिणाम के विपरीत है
* "What would happen if this threshold were raised?"

कोड के लिए उदाहरण इनपुट LLM:

```json
{
  "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" }
  ]
}
```

That'is not a log stream **तर्क आधार**.

एक कोड एलएलएम अब कर सकता है

* कारण स्पष्ट करें ("गुणवत्ता के कारण स्केलेशन ट्रिगर किया गया
* कमजोर लिंक पहचानें (" अस्तित्व निष्कर्ष विश्वास असफलता पर प्रभाव डालता है
* कम करने की सिफारिश करें (" escalating से पहले एक भिन्न निष्कर्षक चलाएँ
* कॉन्फ़िगरेशन परिवर्तन प्रस्तावित करें ("lower entity min

सभी के लिए विश्वास नहीं किया जाता *करना* कुछ भी

### डिबगिंग निरीक्षण हो जाता है

पारंपरिक "LLM त्रुटि सटीन करने के लिए प्रयास करता है

> यह कोड और कुछ लॉग्स है

StyloFlow डिबगिंग सरल है:

> "यहाँ observed सिस्टम की सही स्थिति है

क्योंकि संकेत अपरिवर्तनीय हैं और स्वामित्व के होते हैं

आप पहले से ही विश्वास कर रहे तथ्यों पर LLM कारण

### क्यों यह एमएसके0 एजेंट रंगमंच में नहीं बदलता

यह केवल कठोर सीमाओं के कारण काम करता है

* एलएलएम कर सकते हैं **विश्लेषण करना** संकेत
* निर्धारक कूट **कार्य** संकेतों पर
* सिर्फ प्रकट करता है और कोड परिवर्तन व्यवहार

कोई फीडबैक लूप नहीं है जहां LLM "decides"the next stepM SK2MostlyMSC3it proposes explanations or configuration suggestions that a human (or deterministic policyMST5 may apply laterMSP6

यह असमानता जानबूझकर है

### एक पक्ष-प्रभाव:अगामी स्वायत्तता के बिना ट्युनिंग

एक बार संकेतों, विश्वास, और परिणाम स्पष्ट हैं *शक़्ति* बाद में

* खनन ऐतिहासिक संकेत पदचिन्ह
* मूल्यांकन करें कि किस वृद्धि ने मदद की
* ट्युन थ्रेसहोल्ड ऑफ़लाइन
* लेन के बीच तरंगों को बढ़ावा देना या कम करना

इनमें से कोई भी LLM को सिस्टम चलाने की अनुमति नहीं देता

एलएलएम एक बन जाता है **निदान लेंस**एक नियंत्रण सतह नहीं है

### यह क्यों महत्वपूर्ण है

स्टिलियोफ्लो केवल संभाव्यतावादी प्रणालियों को सुरक्षित नहीं करता है

यह उन्हें बनाता है **बोधनीय** मानव के लिए — परीक्षण के लिए , और LLMs के लिए बिना नियंत्रण छोड़े —

कि ''' के बीच अंतर है

* आपका तंत्र चला रहा है
* और "LLMs आपके सिस्टम को समझते हैं

उन मापों में से केवल एक

---


## आपात गुण

**1. घोषणात्मक संरचना**

अवयव अपनी संविदाएं घोषित करते हैं (ट्राइगर्स\, सिग्नलों को\,\बैजैट को\ ),\ उनकी निर्भरताओं को नहीं देता है\M SK4\ सिस्टम निष्पादन आदेश का पता लगाता है

**2. डिफ़ॉल्ट से देखने योग्य**

प्रत्येक क्रिया एक संकेत है।

**अनुकूलित निष्पादन**

विश्वास प्राप्तियां बिना स्पष्ट रूटिंग तर्क के शाखाओं को चलाती हैं।

**4. माकिंग फ्रेमवर्क के बिना परीक्षण योग्य**

मोक संकेतों, अवयव नहीं

```csharp
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);
```

**5. वृद्धिशील जटिलता**

सरल प्रारंभ करें

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

आवश्यकता होने पर संकेत जोड़ें:

```csharp
new EphemeralOptions { Signals = signalSink }
```

के लिए तरंग जोड़ें

```csharp
var waveCoordinator = new WaveCoordinator(waves, profile);
```

घोषणात्मक कॉन्फ़िगरेशन के लिए परिपत्र जोड़ें:

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

---


## पूर्ण पाइपलाइन: lucidRAG दस्तावेज़ इंजेक्शन

यहाँ' पूर्ण है [सुस्पष्टRAG](/blog/lucidrag-multi-document-rag-web-app) पाइपलाइन पर एक नज़र (see the detailed code examples in the

1. **अपलोड करें** → `document.uploaded` संकेत
2. **फ़ाइल प्रकार तरंग** पता चला PDF/DOCX/Markdown M SK2 `file.extension` संकेत
3. **एक्सट्रैक्शन वेव** पाठ और संरचना खींचता है `text.extracted` संकेत
4. **क्रें** अर्थिक रूप से विभाजित है → `document.chunked` संकेत
5. **एम्बेडिंगवाव** वेक्टर उत्पन्न करता है (parallel `embeddings.generated` संकेत
6. **एंटिटीवेव** इकाइयों को निकालता है (parallel `entities.extracted` संकेत
7. **क्वालिटीवाव** पूर्णता की जाँच करता है → `quality.score` संकेत
8. **EscalationWave** यदि गुणवत्ता है तो ( conditional `escalation.complete` संकेत
9. **भंडारण तरंग** Qdrant + PostgreSQL → में बना रहता है `storage.complete` संकेत

UI वास्तविक के लिए SignalSink पर सदस्यता लेता है

```csharp
// 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
            });
    }
});
```

या यदि आप मतदान करना पसंद करते हैं तो खींच पैटर्न का उपयोग करें

```csharp
// 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);
}
```

**कुंजी बिंदु** You subscribe to the SINK (which views all atoms), not to individual operations

यह कैसे है [सुस्पष्टRAG](/blog/lucidrag-multi-document-rag-web-app) एक एकीकृत संकेत के माध्यम से दस्तावेज़ों, आंकड़े, और छवियों को प्रक्रमित करता है [डॉक-सममैरिजर](/blog/building-a-document-summarizer-with-rag), [डेटा-सममारीजरName](/blog/datasummarizer-how-it-works), और [ImageSummarizerComment](/blog/constrained-fuzzy-image-intelligence) एक ऑरेक्स्ट्रेशन परत के नीचे

---


## पूर्ण पाइपलाइन: स्टिलोबोट बोट पता लगाने

यहाँ' पूर्ण है [स्टाइलोबोट](https://www.stylobot.net) पाइपलाइन पर एक नज़र (विशिष्ट कोड में देखें

1. **आईपी रिपुटेशन वेव** ज्ञात बॉट सूची के विरुद्ध आईपी जाँच करता है (< 10ms) | `bot.detected` विश्वास के साथ संकेत
2. **व्यवहार विश्लेषण तरंग** (शर्त है यदि |0.4 | | < | विश्वसनीयता को विश्लेषित करता है उपयोक्ता एजेंट और क्लिक पैटर्न `bot.detected` संकेत
3. **एलएलएम-बोट-एनालिसिस-वाव** (conditional यदि अभी भी अस्पष्ट है तो ) वार्तालाप विश्लेषण के लिए LLM का उपयोग करता है `bot.detected` संकेत

प्रमुख लाभ

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

**लागत विभाजन** आईपी जांच लागत $0 और समय का चलता है & #44; 100%। **$0.0001** विपरीत naive "LLM everything" पर **$0.002** बचत

---


## अन्य कार्यप्रवाह इंजिनों की तुलना

विशेषता | स्टिलियोफ्लो || | अस्थायी | | | एयरफ्लो
|---------|-----------|----------|---------|----------------|
| **समन्वय** सिग्नल
| **घोषणात्मक** YAML मैनिस्ट्रेट | ✅ YaML मैनीस्ट्रेट
| **शर्तात्मक** | | ✅ | संकेत ट्रिगर | | 2 | 3 | अवस्थाएं | 4 | 5 | शाखा | 6 | 7 | विकल्प स्थिति | 8
| **उत्तेजना** |  ✅ Built-in
| **प्रेक्षणशीलता** कार्यप्रणाली इतिहास
| **बजट नियंत्रण** | ✅ टोकन
| **स्थानीय निष्पादन** प्रक्रिया में -में
| **प्रतियोगी मार्ग** Pools | | ❌ | सेवा सीमाएँ

**जहाँ यह मॉडल स्वाभाविक रूप से फिट करता है**

- AI/ML पाइपलाइनों में वृद्धि के साथ (चायद | → | महंगा |)
- शर्तात्मक चरणों के साथ दस्तावेज प्रसंस्करण
- बहु-- चरण विश्लेषण के साथ बोट पता लगाना
- हाइब्रिड खोज +Generation
- कोई कार्यप्रवाह जहां घटक विश्वास प्राप्तियों के प्रति प्रतिक्रिया करते हैं

**जहाँ यह नहीं है**

- सरल अनुक्रमिक कार्य (अंतिम समन्वयक पर्याप्त है
- डेटा केंद्रों के बीच परिपक्व वितरित कार्यप्रवाह (Temporal यह हल करता है
- मानव अनुमोदन के साथ चलती कार्यप्रवाह (Temporal/AirflowM SK3
- स्कीमा माइग्रेशन के साथ कार्यप्रवाह संस्करण

---


## जहां यह मॉडल आगे बढ़ता है

> ये मॉडल के स्वाभाविक विस्तार हैं

जैसे-जैसे अर्थ स्थिर होता है lucidRAG और Stylobot विकास के माध्यम से इन पैटर्न व्यवहार्य हो जाते हैं

**1. संकेतों से सीखना**

ट्रैक जो एस्केलेशन पथ सबसे अच्छा काम करता है:

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

**2. लागत अनुकूलन**

ऐतिहासिक निष्पादन पर आधारित स्वचालित लेन आबंटन

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

**3. संकेत फिर से बजाएँ**

संकेत अनुक्रमों को फिर से बजाकर डिबग करें:

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

**मेसिन समन्वयन**

चिह्नों को केंद्रित रखते हुए मशीनों के बीच लेन वितरित करें

---


## क्यों संकेत महत्वपूर्ण हैं

मुख्य अंतर्दृष्टि यह है **अभियांत्रिकी प्रणालियों में प्रत्येक घटक का विश्वास है**.

पारंपरिक कार्यप्रवाह सफलता मानते हैं

- **विश्वसनीय अंक** हम कितने निश्चित हैं
- **निबंधित निष्पादन** - यदि विश्वास हो तो महंगे चरणों को छोड़ें
- **उत्तेजना** - जब अनिश्चित हो तो अधिक कोशिश करें
- **संकलन** - बहुविध संकेतों को जोड़ें

संकेत यह स्वाभाविक रूप से प्रदान करते हैं

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

इसीलिए StyloFlow के लिए अच्छी तरह से काम करता है [कम RAG](/blog/reduced-rag) प्रत्येक निष्कर्षण चरण एक विश्वास प्राप्तांक उत्पन्न करता है

---


## सारांश

**निष्पादन मॉडल**

- प्रथम श्रेणी के तथ्यों के रूप में संकेत
- विश्वसनीयता प्राप्तियां ड्राइव नियंत्रण प्रवाह
- ट्रिगर के माध्यम से तरंग समन्वित करें
- लाइनें संसाधन सीमाओं को लागू करती हैं
- पर बनाया गया [mostlylucid.](/blog/ephemeral-execution-library)

**संकेत क्यों महत्वपूर्ण हैं**

1. **स्थिर वितरण सीमा** - Serializable , timestamped, selfM SK3contained
2. **घोषणात्मक रचना** - घोषणाएं संविदाओं को परिभाषित करती हैं
3. **अनुकूलित रूटिंग** - विश्वसनीयता बिना हार्डकोड शाखाओं के विस्तार को सक्षम करता है
4. **आनुवंशिक अवलोकननीयता** - हर क्रिया पहले से ही एक संकेत है
5. **स्वामित्व साफ करें** - परमाणुओं के अपने संकेतों

**कार्यान्वयन**

- [सुस्पष्टRAG](/blog/lucidrag-multi-document-rag-web-app) - क्रॉस
- [स्टाइलोबोट](https://www.stylobot.net) विश्वास के साथ बोट पता लगाना
- [कम RAG](/blog/reduced-rag) - निर्णायक निष्कर्षण + परिबद्ध एलएलएम संश्लेषण

**संबंधित लेख:**

- [अल्पकालीन निष्पादन लाइब्रेरी](/blog/ephemeral-execution-library) - आधार
- [कम RAG](/blog/reduced-rag) - क्यों निर्णायक निष्कर्ष महत्वपूर्ण है
- [LRU और क्षमता](/blog/learning-lrus-when-capacity-makes-systems-better) मेमोरी
- [प्रतिबंधित अस्पष्ट संदर्भ खींचना](/blog/constrained-fuzzy-context-dragging) सिद्धांत

**स्रोत कोड:** [GitHub - StyloFlow](https://github.com/scottgal/styloflow)

---


## कोर इंस्टीट्यूट

पारंपरिक कार्यप्रवाह इंजन आपको घोषणा करने के लिए पूछते हैं **आगे क्या होता है**. यह मॉडल घटकों से घोषणा करने के लिए पूछता है **जो वे पैदा करते हैं** और **जो उन्हें चाहिए**तब संकेतों को निष्पादन समन्वयित करता है

कुंजी स्विच **संकेत वितरित करें, विश्वास गाइड्स, लेन सुरक्षा**.

यह टाइमरल या एयरफ्लो पर स्टिलोफ्लो चुनने के बारे में नहीं है।

यदि आप AI निर्मित कर रहे हैं

- विश्वास महत्वपूर्ण है ( केवल सफलता नहीं
- उत्तेजना संरचनात्मक है (एक विशेष मामला नहीं है
- घटकों को एक-दूसरे के बारे में नहीं जाना चाहिए
- प्रेक्षणशीलता अंतर्निहित होना चाहिए

तो ये निष्पादन अर्थशास्त्र आप सोचने के तरीके से फिट हो सकता है

 [अल्पकालीन लाइब्रेरी](/blog/ephemeral-execution-library) स्थिर आधार है।

प्रश्नों या प्रतिक्रिया के लिए, देखें [जिटहब रिपोजिटरी](https://github.com/scottgal/styloflow).