This is a viewer only at the moment see the article on how this works.
To update the preview hit Ctrl-Alt-R (or ⌘-Alt-R on Mac) or Enter to refresh. The Save icon lets you save the markdown file to disk
This is a preview from the server running through my markdig pipeline
StyloFlow: Конstrained Fuzzy SignalM SK1Driven Workflows
Sunday, 11 January 2026
Я створив StyloFlow, бо продовжував писати те ж саме знову і знову: компоненти, які реагують на те, що сталося до того , виділяють показники самовпевненості МSK2 і іноді потребують ескалізації до більш дорогих аналізів M SK3 існуючі двигуни робочого потоку хотіли, щоб я думав з точки зору DAG або станових машин
NOTA: StyloFlow - це ще не готовий продуктM SK1 бо я створюю lucidRAG і StyloBot I ' я доставляю недоліки і поліпшую API на обох stylоФлоу та efeмерних. ЦеMSC4 все ще в активному розробці МSK5 але ви можете спробувати його і дати відгукиМSK6 Я обновлюю тут пізніше MSSK7 наприклад, штука SignalSink зміниться для efeмерного vMST8 буде МST9 читати тільки МST10
StyloFlow - це сигнал--", керований оркестровою бібліотекою, що відповідає як я думаю про Трубопроводи штучного інтелекту: компоненти заявляють, що вони виробляють і чого їм потрібно
Це інфраструктура, яка дає енергію прозораРАГ - - інструмент для RAG, що об 'єднує DocSummarizer МSK0документи), DataSummarizer МSK0структуровані дані), і ImageSummarizer (обрисиM SK1 перетворюють в об 'єднане питання-систему підсилення з візуалізацією графів знань Стілобот (сучасна система захисту роботів ) і впроваджує Reduced RAG шаблон.

Источник: GitHub - StyloFlow
Що це таке
StyloFlow - це робочий прототип сигналу API та форма розвиватимуться, коли я будую lucidRAG і Stylobot,, але тут описана семантика виконання та шаблони є точним : сигналами як першими МSK2 класовими фактами M SK3 довірою - рухомим відрізаннямМSK5 і ескалацією як структурним шаблоном MSC6
Це не "'", це не новий DSL або мова робочого потоку, а симантика виконання збудований навколо сигналів, довіруM SK1 та обмеженої ескалації . Сьогодні він працює в-процесі з обмеженою співпадковістю МSK4 Завтра він розповсюдить ланцюги між машинами, зберігаючи сигнали як стабільну межу M SK5
Проблема з традиційними робочими потоками
Ось як виглядає більшість двигунів робочого потоку.
// ❌ 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);
}
Це працює до :
- Ви хочете пропустити видобуток об 'єктів для простих запитів
- Потрібно запустити вилучення та введення паралельно.
- Ви хочете досягнути кращої моделі, заснованої на довірі
- Потрібно додати новий етап обробки, не торкаючись існуючого коду
В результаті ви отримаєте або
- Рігкі труби що не можуть адаптуватися
- Massive if/else дерева для маршрутизування
- Богові класи які знають про все
Фонд МСК0 - тимчасова реакція
StyloFlow будується на більш-менш яскравий.нефемеральний - bibliotekа для обмеженого , відслідковуючих асинхових виконок МSK2
Краткое підсумок того, що дає efeмерний препарат:
// 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}");
Головні переваги efeмерного лікування:
- Обмежена співпадність (не втрачає пам 'ятіM SK1
- Виселення з LRU старих операцій
- Публикація сигналів для співробітництва між компонентами
- Операція з прив 'язками, щоб запобігти передчасному висеченню
Для деталей, читайте Огонь і не забувай.
Що дає ця модель
Ця модель оркестрування розширює ефемеральну з:
- YAML-пілотовані manifestи компонентів - Декларативна конфігурація
- Триггери на основі сигналу- - Komponenти запускаються, коли з 'являються сигнали
- Координація хвиль - Priority-в основі виконання з конкуррентними ланками
- Спостереження ескалації - Покидати дорогою аналізу допоки не буде потрібно
- Контракти podmiotів - ТипM SK1безпечний вхід /показові характеристики
- Керування бюджетом - Ограничення символів МSK1 обмеження витрат МSK2 відхилення часу
Ось ключова зміна в архітектурі:
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
Комп 'ютери ніколи не телефонують одне одному. Вони випускають сигнали і реагують на нихM SK1
Початкова концепція: Сигнали та права власності
Сигнали - це факти про те, що сталося, не накази чи події . Вони МSK2 є незмінними M SK3 записані в певний час, МSK4 і несуть показники довіри, . Кожен атом має свої сигнали. МSK6 вони М SK7 є зовнішнім незмінним . Ніщо інше не може змінити цей список
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; }
}
Критичний архітектурний момент: Сигнальний синк - це тривалий історічний поглядM SK1
Сигнальний запах надає пошуковий вид на всіх операціях на всіх координаторах, які його розділяють. Сигнали продовжують існувати впродовж життєвого циклу координатора - коли операція виїжджає з його координатора МSK2 сигнали залишаються в раковині до того, як їх зачистять ручно
// 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. ПоштовхуванняM SK1на основі
// 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. ПрийтиM SK1на основі (Запрос):
// 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}");
Чому це важливо:
- Просмотр тільки для - SignalSink не може змінювати сигналиM SK1 він лише дає доступ до запиту
- Сигнал не змінюється - Сигнали залишаються в нагоді доки їх операція не видасть від координатора
- Сигнали - це координація, а не транспорт - Сигнали несуть ключі /референції до зовнішніх даних МSK2 Не самі дані
- Незалежність координатора - Множество координаторів можуть ділитися одним сховищем ; історія сигналу розширюється на всі
- Thread-safe - Замок-Свободні odczytи для операцій на запиті
- Натиснути і втягувати - Записуйтесь () для реактивного МSK2 Здібноважність M SK3 Визначати () для голосування
- Корреляція операцій - Кожен сигнал містить OperationId для відстеження через координатори
- Схоже на модель - Попит на основі точного співпадіння
Головний принцип проектування: Поміщати велику кількість даних (документиM SK1 зображенняМSK2 вектори) в кэшах або базах данихMSC4 Сигнали несуть тільки такі reference, як "cache://doc-123" або операційні ключі.
Наприклад, координація:
// 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);
}
});
Ескаляція відбувається на двох рівнях
- В межах координатора - Води перевіряють надійність сигналу і підтримують дорогий аналіз
- Між координаторами - EscalatorAtom маршрутизує сигнали від швидкого координатора → дорогий координатор на основі критеріїв сигналу
// 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
}
Багато координаторів працюють незалежно. ЕскалаторАтом спостерігає за сигналами від одного координатора і передає роботу до іншого, коли це потрібноM SK1
Теорія, що стоїть за цим МСК0 , представлена в Перетягування обмеженого неясного контексту.
Сигнали несуть відмітки, Не дані
Критичний: Сигнали - це координаційні події, не транспортування данихM SK1 великі дані ( документи M SK3 зображення , вбудовані матеріали MSC5 мають бути розташовані в зовнішній накопичуванні МSK6
// ❌ 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);
}
}
Найкращі практики:
- Використовуйте кэши (in-memory або розширеніM SK2 для efeмерних даних
- Використовувати бази даних для довготривалих даних
- Використовувати blob Storage для великих файлів
- Сигнал URIs:
"cache://key","blob://container/file","db://table/id" - Залишити сигнали легкими - просто ключі , запевненість балів МSK2 timestamps
Концепція ядра: Маніфести компонентів
Маніфести оголошують контракти: МСК0, що мене мотивує , ,, що я викидаю , відокремлена від застосування. Ця відокруження існує таким чином, що ви можете зрозуміти робочий процес без читання коду
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
Прибутки:
- Переконфигурація uruchomionego часу - Зміна пріоритету без рекомплікації
- Середовище заперечує - Перезаписувати за допомогою настроекM SK1json
- Прозорі контракти - Подивіться, які сигнали викликають
- Самоусвідомлення - Маніфест - це спецификація
Визуальний роботодавець
В той час, як ви можете написати YAML манифести вручну, StyloFlow включає візуальний будівник робочого потоку, який дозволяє проектувати сигналиM SK1пілотовані робочі потоки за допомогою модульного-synthMスク3таッチування стилюMSC4

В інтерфейсі є::
- Перетягніть компоненти з таксономії ( сенсори МSK1 аналізатори МSK2 запропонувачі , і т.д.
- Сигналове зламування проводу - З 'єднати виходи до входів візуально
- Живий огляд manifestу - Подивіться на генерований YAML, як ви будуєте
- Триггер візуалізації - Подивіться, які сигнали активують які компоненти
- Наділення смуги - Перетягувати деталі до швидких ланцюгів
- Перевірка часу Real- - Вхопити неправильні сигнали негайно
Таким чином, можна легко експериментувати з різними формами робочого потоку, не пишучи YAML вручну.
Керова концепція: Води
Вона - це складний аналіз. Цей інтерфейс існує для того, щоб зробити "мусимо запустити ?" першим МSK2 рішенням класу, це не деталі розробки, закопані в логіці умовних речей
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);
}
Ось приклад простих хвиль:
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 пробігає хвилі у пріоритетному порядку:
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}");
}
Конкуренційні траси:
Води бігають на дорогах з різними обмеженнями співпадіння:
| Шоссе МSK1 Мета МSK2 Конкуренція | ||
|---|---|---|
fast |
Швидкі перевірки ( Проверка IP МSK2 тип файлуM SK3 МSK4 \16 | |
normal |
Стандартне оброблення | |
io |
IM SK1O пов 'язане (файл читає, API дзвінкиMSC4 МSK5 \32 | |
llm |
дорогі LLM дзвінки |
Це запобігає блокуванню дорогих операцій
Архітектура: Як вона поєднується
Ось цілковита картина
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
Потік:
- Вхід приходить: ( HTTP прохання , файл МSK2 робота
- Ефемерний координатор створює операцію (, яка володіє пустим списком сигналів
- Операція додає сигнали до свого списку
- Координатор хвиль READS сигнали через View SignalSink, щоб перевірити умови триггера
- Води, чиї триггери співпадають, запускаються у пріоритетному порядку в рамках дорожніх смуг.
- Кожна хвиля додає сигналів до своєї операції'власний список M SK1взовні неизм 'юваний)
- Координатор хвиль продовжує читати сигнали, щоб знаходити новозадоволені триггери
- Останнє питання вихідного сигналу SignalSink читає сигнали і визначає дії
Модель власності: Кожна операція /атом має свої сигнали МSK1 Сигналсинк дає читаний МSK2 тільки для всіх операцій . Сигнали можуть бути ескалізовані | ( | копіовані \ ) | чи відековані | МSK6 | зачувані, коли їх викидають |), | але список власників не змінюється ззовні
Текучий модель виконання: pojedynczy-процесM SK1 обмежене співпадіння , спостереження за операціями з виведенням LRU.
Майбутня модель виконання: Розповсюдині ланцюги через машини, СигналSink запитує віддалені операціїM SK1 атоми виконуються на різних хостах. Сигнали залишаються стабільними - вони ' вже сеrialізовані МSK2 в timestamped МSK3 і саморобні
Implementation in- підтверджує семантику . Distribution about scaling the execution substrate
Використовуйте Cas: lucidRAG документообробка
Давайте подивимось, як lucidRAG використовує StyloFlow:
Стадія 1: Початкове виявлення
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: Поєднання ( з 'єднане файлом
// 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: Втілення ( з 'єднане документом
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: Видобуток об 'єктів МSK1паралельний з вмонтуванням МSK2
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: Проверка якості
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;
}
}
Прибутки такого підходу
- Паралельне виконання - Введення і видобуток об 'єктів запускаються одночасно
- Суворі відтінки - перевірка якості вирішує, чи потрібна ескалація
- Поділений контекст - Рухи отримують доступ до шматків, не переміщуючи їх явно
- Легко розширювати - Dodaj нову хвилю, не змінюючи існуючих
- Дослідження - Кожна стадія випромінює сигнали, які можна контролювати
Це Reduced RAG візерунок в дії: детерміністичне видобуток на передній плані , ЛЛМ лише для синтезу
Використовуйте пристрій : Смітник Bot Detection
Стілобот це розвинена система виявлення роботів, яка використовує систему StyloFlow для аналізу загроз у різних стадіях.
Сигнал-Різови Оркестрування
Модель 1: вентилятор - Виход
Один сигнал активує багато хвиль:
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: Последовательна залежність
Води чекають на попередні сигнали:
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: Кондиційне відокремлення
Різні хвилі запускаються на основі сигналів:
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: Об 'єднання
Багато сигналів активують одну хвилю:
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
Моделі ескалації
StyloFlow підтримує ескаляцію на двох рівнях:
- Внутрішній koordinatор: Води перевіряють довіру сигналу і під час умов запускають дорогие кроки
- Розподіл koordinatora: EscalatorAtom маршрутизує сигнали від швидкого координатора
До прикладу з lucidRAG: Спочатку запускається швидке видобуток об 'єктів. Якщо якість M SK2 0.7, EscalatorAtom спрямовує документ до дорогих координаторів покращення LLMMSC4 Це заощаджує МSK5x kosztów, не звертаючи уваги на дорогі виклики LLM для високої якості extractions
Найменша форма
Це не швидкий-початковий інструктор; цеM SK2 найменший приклад, який показує, як модель вписується в одне ціле
Установлення:
dotnet add package StyloFlow.Complete
Концепційна точка входу:
// 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})");
}
З manifestами:
// 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);
Для повних прикладів, см. Репозиторium StyloFlow GitHub.
Відкритість робочого процесу: YAML Маніфести
Маніфести розповідають про те, що спричиняє хвилю: МСК0; що вона викидає: МSK1; обмеження ресурсів: ,; витрати: M SK3; створення власного робочого потоку; МSK4; документування.
Наприклад: Детерміністична хвиля
name: ChunkingWave
priority: 80
description: Splits documents into semantic chunks
taxonomy:
kind: extractor
determinism: deterministic
triggers:
requires:
- signal: file.extension
condition: in
value: [".pdf", ".docx", ".md"]
emits:
on_complete:
- key: document.chunked
type: integer
lane:
name: normal
max_concurrency: 8
budget:
max_duration: 30s
defaults:
chunking:
max_chunk_size: 512
overlap: 50
До прикладу: умовна ескалація
name: QualityCheckWave
priority: 40
description: Validates extraction quality
triggers:
requires:
- signal: embeddings.generated
- signal: entities.extracted
emits:
on_complete:
- key: quality.score
confidence_range: [0.0, 1.0]
conditional:
- key: escalation.needed
when: quality.score < 0.7 # Trigger LLM refinement
lane:
name: fast
max_concurrency: 16
Прибутки:
- Порядок виконання видимий з номерів пріоритету
- Відлежність від необхідних сигналів
- Конкретні обмеження ресурсів (ланиM SK1 бюджети )
- Привілейний логічний декларатив
Невідкладні властивості
1. Декларативний состав
Комп 'ютери розповідають про свої контракти ( триггери , сигнали МSK2 бюджет M SK3 не їхні відлежності . Система визначає порядок виконання MSC5 Це не МSK6 це не функція МСК7 це MСК8 це те, що відбувається, коли ви створюєте сигнали першимиМСК9 клас М СК10
2. По замовчуванню
Кожна дія - це сигнал.
3. Адаптивна виконання
Результати впевненості спричиняють розгалуження без чіткої логіки маршрутізації. Перемикаємо дорогоцінні етапи, коли це необов 'язковоM SK1 ескалізуємо, коли не впевнимосяМSK2 перекидаємо на ранній час на високий рівеньMSC3 невдачі в упевненні. Контрольний поток виникає з візерунок сигналівMスク5
4. Випробовуваність без вмонтування каркасів
Помітні сигнали, не складовіM SK1
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. Зростає складність
Почнемо з простого:
var coordinator = new EphemeralWorkCoordinator<Job>(ProcessAsync);
Додайте сигнали, коли це потрібно:
new EphemeralOptions { Signals = signalSink }
Додайте хвилі для мульти-станційM SK1
var waveCoordinator = new WaveCoordinator(waves, profile);
Додайте manifests для декларативної konfiguracji:
name: MyWave
triggers: [...]
emits: [...]
Порівняння з іншими машинами Workflow
\✅ JSON \МSK9 \YAML \МСК10
| Funkція МSK1 StyloFlow МSK2 Temporal | Airflow မ်SK4 Поступні функції мSK5 | ||||
|---|---|---|---|---|---|
| Координація | Сигнал МSK1пілотований МSK2 РПЦ -на основі СМСК4 DAG СМСК5на базі МСК6 Стаціонарний станок MSК7 | ||||
| Засвідчення МSK0 ✅ YAML-моніфести МSK2 ❌ Код мSK4перший МСК5 МСК6 DAGs M | За умови МSK0 ✅ Сигнал триггерів МSK2 ✅ Ситуація МСК4 МСК5 Розподіл СМСК6 СМСК7 Статі вибору MSК8 | ||||
| Ескаляція МSK0 ✅ ЗбудованийM SK2всередині МSK3 ♫ ♫ МSK4 ♫ Руководство ♫ | ♫ | ||||
| Обсервабельність | МSK1 Сигналовий слід МSK2 \ ✅ Історія робочого потоку | ✅ Записи задач ♫ | ♫ | МSK7 ♫ Історії виконання ♫ МSK8 ♫ | |
| Kontrolа бюджету МSK0 ✅ Знак МSK2Ceilingи витрат | |||||
| Локальне виконання МSK0 ✅ ВМСК2процесі МСК3 \MСК4 Потрібний кластер мСК5 | МСк6 | Потрібна кластер | |||
| Конкуренційні траси МSK0 ✅ Гнучкий МSK2Normalny /LLM MSК4 \❌ Ручний МСК6 | ✅ Бассейни СМСК8 ♫ | СМСК9 Ограничення служби СМСк10 |
Де ця модель підходить природно:
- AI/ML трубопроводи з ескалацією M SK1швидкі → дорогі МSK3
- Обробка документів за умовними етапами
- Розпізнавання бота з wieloступенчальним аналізом
- Системи RAG з гібридним пошуком покоління +
- Будь-який робочий процес, де компоненти реагують на показники довіри
Там, де він не виграв
- Прості послідовні завдання (вистачає невеликого koordinatora )
- Дорослі розподілені робочі потоки через центри обробки даних. (Temporal вирішує це.
- Довгий-працюючі робочі потоки з людським підтвердженням M SK1Tempоральний/АэропотокMSC3
- Версію робочого потоку з схемою міграції (Temporal)
Куди рухається ця модель
Це природні розширення моделі, а не зобов 'язання нанести певний результат.
Коли семантика стабілізується через розвиток lucidRAG та Stylobot, ці шаблони стають жизнетворними.
1. Навчання з сигналів
Прослідкувати, які шляхи эскалації найкраще працюють:
// Did the LLM escalation improve accuracy?
// Learn to skip it if behavioral analysis is sufficient
2. Оптимізація витрат
Автоматичний розподіл ланцюга на основі історичного результату:
// If a "slow" wave completes quickly, promote to "normal"
3. Сигнальний повтор
Розлад, відтворюючи послідовності сигналів:
var replay = SignalReplay.FromFile("trace.jsonl");
await coordinator.ReplayAsync(replay);
4. Мульти-
Поширювати лінію між машинами, зберігаючи центральні сигнали.
Чому сигнали важливі
Найголовнішим моментом є це. в системах штучного інтелекту, МСК0, кожен компонент має впевненість.
Традиційні робочі потоки припускають успіх
- Результати впевненості - Наскільки ми впевнені в цьому?
- Виконування за умовами - Якщо ви впевнені, пропустити дорогих етапів
- Ескаляція - Попробуйте ще більше, коли не впевнений
- Об 'єднання - Об 'єднати кілька сигналів
Сигнали роблять це природно:
// 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 працює добре для Reduced RAG - кожен етап видобутку виробляє показник самодовіри ,, а синтез відбувається лише тоді, коли самодоверість достатньо висока M SK2
Підсумок
Модель виконання:
- Сигнали як перші-факти класу МSK1не події чи повідомленняM SK2
- Довіра оцінює рух управління потоком
- Води координуються за допомогою триггерів, а не прямих дзвінків
- Автодоріжки вказують на обмеження ресурсів
- Побудований на більш-менш яскравий.нефемеральний
Чому сигнали важливі:
- Стабільна межа розподілу - Серіалізуюча , в timestamped МSK2 автономна M SK3 заwarte
- Декларативний состав - Маніфести визначають контракти
- Адаптивне маршрутизування - Упевненість дозволяє ескалізацію без закодованих відрізків
- Власна спостережливість - Кожна дія вже є сигналом
- Звільнити власника - Атомові власні сигналиM SK1 зовнішній безперервність запобігає дії
Працові втілення:
- lucidRAG - КрестM SK1модальний документ Q&A з умовним виділенням об 'єктів
- Стілобот - Детективність Bot з впевненістюM SK1подібна ескалація (IP МSK3 поведінка МSK4 LLM)
- Reduced RAG - Детерміністичне видобуток
Подібні статті:
- Бібліотека швидкого виконання - Основа
- Reduced RAG - Чому має значення детерміністичне видобуток
- ЛРУ та пропускна спроможність - Пам 'ятьM SK1 замкнуті вікна
- Перетягування обмеженого неясного контексту - Теорія
вихідний код: GitHub - StyloFlow
Погляньмо на суть
Традиційні машини робочого потоку просять вас оголосити що ж відбувається далі. Ця модель просить компоненти заявити що вони виробляють і що вони потребують, тоді дозволяє сигналам координувати виконання
Переміщення ключів: сигнали відокремлюються, інструкції довіриM SK1 захист.
Це не "'", це StyloFlow , а Temporal чи Airflow . - , які розв 'язують різні проблеми. МSK2 , Durabilitatea execution , , , версування робочого потоку, , , розподілена координація між центрами обробки даних, МSK5 . Це articulating a different orchestration model , МSK6 , де контрольний потік виникає з візерунок сигналів, замість того, щоб бути явно програмованим.
Якщо ви будуєте трубопроводи AI/ML де
- Упевненість має значення. ( не лише успіх
- Ескаляція є структурною. (не особливий випадок
- Компоненти не повинні знати одне про одного
- Обсервабельність має бути невід 'ємною. (не підштовхується на МSK1
... тоді ця семантика виконання могла б підійти до того, як ви думаєте
І тимчасова бібліотека є стабільним фундаментом. StyloFlow додає сигналу - підштовхований оркестровий шар зверху МSK2 Обидві з них розвиваються через реальне використання в lucidRAG та Stylobot .
Для питань або зворотнього зв 'язку, читайте Репозиторія GitHub.