Slickflow

Current Version: NET8

1. 🤖 AI-Powered Workflow Automation

SlickFlow: Intelligent Workflow Automation with Large Language Models

Slickflow integrates cutting-edge Large Language Model (LLM) nodes directly into BPMN workflows, enabling advanced conversational reasoning, RAG (Retrieval-Augmented Generation), image understanding and other AI capabilities as first-class workflow steps.
This transforms traditional workflow systems into dynamic, AI-driven orchestration platforms.

1.1 Native LLM Node Integration

• Add LLM / RAG / Agent nodes into your process diagrams as easily as traditional service tasks.
• Orchestrate multi-step AI pipelines: prompt construction, tool calls, knowledge base retrieval, post-processing, persistence, notification, etc.

1.2 Multi-Provider LLM Support

Flexible integration with leading AI services:

• OpenAI API (GPT-4, GPT-3.5, and beyond)
• QianWen (Alibaba’s large language model)
• Extensible architecture for additional providers (DeepSeek, custom gateways, etc.)

1.3 Image Understanding & RAG

• Image classification & analysis directly through LLM nodes
• Retrieval-Augmented Generation (RAG): combine vector search / knowledge bases with LLM reasoning to provide grounded, up-to-date answers

1.4 AI Feature Reference

• Detailed article: Slickflow.AI – Large Language Model Integration

1.5 AI Demo (Key GIF)

AI Image Classification Process Demo

2. 📐 Business Rules Engine

Slickflow includes a built-in Business Rules Engine that lets you define, store and evaluate conditional logic without changing application code.

2.1 Rule Definition

Rules are authored in the designer or via API and stored in the wf_rule_set table. Each rule set contains one or more expressions that evaluate process variables at runtime.

// Evaluate a rule set by name against the current process variables
IWorkflowService wfService = new WorkflowService();
var ruleResult = wfService.EvaluateRuleSet("CreditCheckRules", variableDict);

2.2 Conditional Routing

Rules are attached to gateway transitions in BPMN diagrams. When the engine reaches a split gateway, it evaluates the rule expressions and follows the matching branch automatically — no custom code required.

Typical patterns:

• Amount threshold routing – order amount > 10,000 → senior approval branch
• Status-based branching – inventory level check → reorder or skip branch
• AI output routing – LLM confidence score → accept or human-review branch

2.3 Rule + AI Combination

Business rules can be combined with AI nodes in the same process:

1. An LLM node produces a structured output (JSON with a score field).
2. A split gateway evaluates a rule against the score variable.
3. The process routes to different downstream activities accordingly.

3. 🤝 Multi-Agent Interaction

Slickflow supports multi-agent orchestration within a single workflow, based on the ReAct (Reason → Act → Observe) loop pattern.

3.1 ReAct Agent Loop

Each Agent node in the process diagram runs an autonomous reasoning loop:

1. Reason – the agent analyzes the current task and available tools.
2. Act – it calls a registered tool (API, sub-agent, database query, etc.).
3. Observe – it receives the tool result and decides the next step.
4. The loop repeats until the agent produces a final answer.

// Agent node execution (simplified internal flow)
var agentService = new AgentMultiTurnService();
var response = await agentService.InvokeWithHistoryAsync(axConfig, inputVariables, history);

3.2 Agent Tool Registry

Tools are registered per activity via AgentToolRegistry. Each tool is a typed C# class implementing IAgentTool:

AgentToolRegistry.Register("PriceQuery", activityId, new PriceQueryTool());
AgentToolRegistry.Register("InventoryCheck", activityId, new InventoryCheckTool());

The agent selects and invokes tools autonomously based on its reasoning.

3.3 Multi-Agent Workflow Example

A 5-agent procurement process demonstrates cross-agent collaboration:

Each agent passes its structured output as process variables to the next agent, enabling a full collaborative reasoning chain within one BPMN process.

3.4 Agent Memory

AgentConversationMemory maintains per-session dialogue history across agent turns, allowing agents to reference earlier reasoning steps without re-processing.

4. 🔌 MCP Server

Slickflow provides a Model Context Protocol (MCP) Server (sfmcp) that exposes the workflow engine as a set of callable tools for AI orchestration platforms.

4.1 What It Does

AI assistants (Claude, GPT, etc.) can call Slickflow MCP tools directly to:

• Create and manage workflow process definitions
• Start process instances and run task steps
• Query running instances and task lists
• Read and write process variables
• Trigger AI-node execution within running workflows

4.2 Available Tools (14)

4.3 Quick Start

# Run the MCP server
cd source/sfmcp
dotnet run

Configure your AI platform to point at the MCP endpoint. The server communicates over the standard MCP protocol (stdio or HTTP transport).

4.4 Use Cases

• AI-driven process automation: let an AI assistant start and advance workflows based on natural-language instructions.
• Workflow introspection: query running instances and diagnose stuck processes via chat.
• Dynamic variable injection: an AI agent writes computed results back into a live process instance.

5. 🚀 Code-Defined Auto-Execution Engine

Besides designer-based processes, Slickflow provides a code-first auto-execution model based on Slickflow.Graph and WorkflowExecutor.
You can define workflows in C#, run them fully in memory, and let the engine automatically execute all steps without human interaction.

5.1 Code-First Workflow Definition

Use Slickflow.Graph.Model.Workflow to build BPMN-style flows programmatically:

using Slickflow.Graph.Model;

var wf = new Workflow("Order Process", "OrderProcess_Code");

wf.Start("Start")
  .ServiceTask("Validate Order", "Validate001", "ValidateOrder")   // LocalMethod
  .ServiceTask("Calculate Amount", "Calc001", "CalcAmount")       // LocalMethod
  .RagService("RAG Reply", "RAG001")                              // RAG AI node
  .LlmService("LLM Enrich", "LLM001")                             // General LLM node
  .ServiceTask<SaveOrderService>("Save Order", "Save001")         // Local service class
  .End("End");

Key points:

• Workflow supports rich node types: Start, Task, ServiceTask, RagService, LlmService, Agent, Parallels, Branch, End, etc.
• BuildInMemory() produces an in-memory ProcessEntity without touching the database.
• WorkflowExecutorExtensions.UseProcess(Workflow) binds this in-memory model to the runtime engine and caches it by ProcessId:Version.

5.2 Auto-Execution with WorkflowExecutor

Auto-execution loop (conceptual):

1. Start the process and create an instance.
2. While there are executable activities:
   • Collect next activities.
   • Execute each activity (local method, service class, AI/RAG/LLM, external API, etc.).
   • Move the process forward to the next activity.
3. Return execution result (status, message, variables, AI response, etc.).

Typical code pattern:

using Slickflow.Engine.Executor;
using Slickflow.Engine.Core.Result;

var result = await new WorkflowExecutor()
    .UseApp("OrderApp-001", "OrderApp")
    .UseProcess(wf)