Current Version: NET8
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.
- 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.
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.)
- 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
- Detailed article: Slickflow.AI โ Large Language Model Integration
AI Image Classification Process Demo
Slickflow includes a built-in Business Rules Engine that lets you define, store and evaluate conditional logic without changing application code.
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);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
Business rules can be combined with AI nodes in the same process:
- An LLM node produces a structured output (JSON with a
scorefield). - A split gateway evaluates a rule against the
scorevariable. - The process routes to different downstream activities accordingly.
Slickflow supports multi-agent orchestration within a single workflow, based on the ReAct (Reason โ Act โ Observe) loop pattern.
Each Agent node in the process diagram runs an autonomous reasoning loop:
- Reason โ the agent analyzes the current task and available tools.
- Act โ it calls a registered tool (API, sub-agent, database query, etc.).
- Observe โ it receives the tool result and decides the next step.
- 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);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.
A 5-agent procurement process demonstrates cross-agent collaboration:
| Agent Node | Role |
|---|---|
| NeedsAnalysisAgent | Analyzes purchase requirements |
| SupplierQueryAgent | Queries supplier catalog and pricing |
| PriceNegotiationAgent | Negotiates terms with selected supplier |
| RiskAssessmentAgent | Evaluates compliance and financial risk |
| ApprovalDecisionAgent | Makes final approval recommendation |
Each agent passes its structured output as process variables to the next agent, enabling a full collaborative reasoning chain within one BPMN process.
AgentConversationMemory maintains per-session dialogue history across agent turns, allowing agents to reference earlier reasoning steps without re-processing.
Slickflow provides a Model Context Protocol (MCP) Server (sfmcp) that exposes the workflow engine as a set of callable tools for AI orchestration platforms.
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
| Category | Tools |
|---|---|
| Process Definition | GetProcessList, GetProcessDetail, CreateProcess |
| Instance Control | StartProcess, RunProcess, GetProcessInstance |
| Task Management | GetTaskList, GetTaskDetail, CompleteTask |
| Variables | GetVariables, SetVariable |
| Knowledge Base | SearchDocuments, SaveDocument, GetDocuments |
# Run the MCP server
cd source/sfmcp
dotnet runConfigure your AI platform to point at the MCP endpoint. The server communicates over the standard MCP protocol (stdio or HTTP transport).
- 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.
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.
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:
Workflowsupports rich node types:Start,Task,ServiceTask,RagService,LlmService,Agent,Parallels,Branch,End, etc.BuildInMemory()produces an in-memoryProcessEntitywithout touching the database.WorkflowExecutorExtensions.UseProcess(Workflow)binds this in-memory model to the runtime engine and caches it byProcessId:Version.
Auto-execution loop (conceptual):
- Start the process and create an instance.
- 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.
- 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) // Use code-defined workflow
.AddVariable("OrderId", "ORD-2025-001")
.AddVariable("Quantity", "3")
.AddVariable("UnitPrice", "99.50")
.Run();This mode is ideal for:
- ETL and data pipelines
- Backend batch / microservice orchestration
- AI agents and chat workflows
- Unit tests and demos (no DB dependency)
- .NET, cross-platform: works on Windows, Linux, macOS.
- BPMN2-style diagrams with an HTML5 designer for visual modeling.
- High performance with Dapper.NET micro-ORM.
- Multi-database support: SQL Server, Oracle, MySQL, PostgreSQL and others (via Dapper / EF Core).
On top of AI and auto-execution, Slickflow remains a full-featured human-centric workflow engine for traditional BPM scenarios: approvals, reviews, multi-level routing, etc.
Supported patterns (BPMN-style):
- Sequence โ the most common pattern
- Split / Merge โ AND / OR gateways with conditions on transitions
- Sub-process โ start a child process from the main flow
- Multi-instance โ multiple performers handle the same task (sequence or parallel), with count/percentage thresholds
Slickflow manages human tasks with features such as:
- Start / Run โ launch and move a process instance to the next step
- Withdraw โ pull back a task you just sent to the next user
- SendBack โ send a task back to the previous step
- Resend / Reverse / Jump โ advanced control for exception handling and special routing
Code style (simplified):
// Start a process instance
IWorkflowService wfService = new WorkflowService();
var startResult = wfService.CreateRunner("10", "Jack")
.UseApp("DS-100", "Book-Order", "DS-100-LX")
.UseProcess("PriceProcessCode")
.Start();
// Run to next step
var runResult = wfService.CreateRunner("10", "Jack")
.UseApp("DS-100", "Book-Order", "DS-100-LX")
.UseProcess("PriceProcessCode")
.NextStepInt("20", "Alice")
.Run();You can also define simple approval processes purely in code (sequence example) using Workflow:
using Slickflow.Graph.Model;
// create a simple sequence process diagram by hand code rather than an HTML designer
var wf = new Workflow("simple-process-name", "simple-process-code");
wf.Start("Start")
.Task("Task1")
.Task("Task2")
.End("End");
This gives developers both designer-based and code-based options for modeling human approval workflows.
WebDemo,MvcDemo,WinformDemoโ example integration with different enterprise application types.
- Software teams or companies who want to embed a workflow engine into their products.
- Developers who prefer combining AI orchestration, auto-execution, and human approval in one engine.
- License: Slickflow follows the MIT open source license and can be used in commercial projects.
- Technical Support: Enterprise, Ultimate and Universe editions can be provided with technical support and upgrade services.
If you have any further inquiry, please feel free to contact:
- Email (Support): support@ruochisoft.com
- English: http://doc.slickflow.net
- ไธญๆ: http://doc.slickflow.com
- English: http://www.slickflow.net
- ไธญๆ: http://www.slickflow.com
- Demo: http://www.slickflow.com/demo/index
- Designer Demo: http://demo.slickflow.com/sfd/
Pre-built Docker images are available on Docker Hub. Get started in minutes without building from source.
The easiest way to get started โ pull one image and run all three services:
docker pull besley2096/slickflow-all:latest
docker run -d \
-p 5000:5000 \
-p 5001:5001 \
-p 8090:8090 \
-e WfDBConnectionType=PGSQL \
-e WfDBConnectionString="Server=host.docker.internal;Port=5432;Database=wfdbbpmn2;User Id=postgres;Password=your-password;TimeZone=UTC;" \
--name slickflow-all \
besley2096/slickflow-all:latestAccess:
- Frontend Designer: http://localhost:8090
- Backend API: http://localhost:5000
- WebTest: http://localhost:5001
Docker Hub: https://hub.docker.com/r/besley2096/slickflow-all
For better isolation and scaling, use separate images:
Backend API
docker pull besley2096/slickflow-api:latest
docker run -d -p 5000:5000 \
-e WfDBConnectionType=PGSQL \
-e WfDBConnectionString="Server=host.docker.internal;Port=5432;Database=wfdbbpmn2;User Id=postgres;Password=your-password;TimeZone=UTC;" \
--name slickflow-api \
besley2096/slickflow-api:latestFrontend Designer
docker pull besley2096/slickflow-designer:latest
docker run -d -p 8090:8090 \
--name slickflow-designer \
besley2096/slickflow-designer:latestWebTest
docker pull besley2096/slickflow-webtest:latest
docker run -d -p 5001:5001 \
-e WfDBConnectionType=PGSQL \
-e WfDBConnectionString="Server=host.docker.internal;Port=5432;Database=wfdbbpmn2;User Id=postgres;Password=your-password;TimeZone=UTC;" \
--name slickflow-webtest \
besley2096/slickflow-webtest:latestUse docker-compose.hub.yml from this repository:
docker-compose -f docker-compose.hub.yml pull
docker-compose -f docker-compose.hub.yml up -dAvailable tags for each image:
latestโ Latest stable versionv3.5.0โ Version 3.5.0
- https://hub.docker.com/r/besley2096/slickflow-all
- https://hub.docker.com/r/besley2096/slickflow-api
- https://hub.docker.com/r/besley2096/slickflow-designer
- https://hub.docker.com/r/besley2096/slickflow-webtest
API and WebTest containers require database configuration. Supported databases: PostgreSQL, MySQL, SQL Server, Oracle.
Database on Host Machine
-e WfDBConnectionString="Server=host.docker.internal;Port=5432;Database=wfdbbpmn2;User Id=postgres;Password=your-password;TimeZone=UTC;"Database in Docker Container
-e WfDBConnectionString="Server=postgres;Port=5432;Database=wfdbbpmn2;User Id=postgres;Password=your-password;TimeZone=UTC;"Remote Database
-e WfDBConnectionString="Server=192.168.1.100;Port=5432;Database=wfdbbpmn2;User Id=postgres;Password=your-password;TimeZone=UTC;"- Email: sales@ruochisoft.com
- QQ (Author): 47743901
- WeChat (Author): besley2008
Your donation will be used for the continuous research and development of the product and community building.
ๆจ็ๆ่ต ๅฐ็จไบไบงๅ็ๆ็ปญ็ ๅๅ็คพๅบๅปบ่ฎพใ
