Flowlitics Backend Engine & API

The robust and scalable core powering your automated workflows, offering extensive control and integration capabilities.

Backend Architecture

Built with Node.js, Express, and TypeScript, leveraging MongoDB for data persistence. Designed for reliability and in-process execution.

---
config:
  flowchart:
    htmlLabels: false
---
graph TD
    subgraph "Initiators"
        direction LR
        User["`User / Frontend UI`"]
        Scheduler["`Cron Scheduler
        (node-cron)`"]
    end

    subgraph "Sistema Flowlitics Backend"
        direction TB
        
        subgraph "API Layer (Express.js)"
            API_Gateway["`API REST
            (Server Express)`"]
            Validation["`Input Validation
            (Joi)`"]
        end

        subgraph "Core Logic & Services"
            FlowService["`Flow Service
            (Gestione Flow)`"]
            ExecutionService["`Execution Engine
            (Esegue i nodi in-process)`"]
            PluginSystem["`Node Executor
            (Carica e usa SDK esterni)`"]
        end

        API_Gateway -- "HTTP Requests" --> Validation
        Validation -- "Valid Data" --> FlowService
        Validation -- "Valid Data" --> ExecutionService
        
        ExecutionService -- "Esegue" --> PluginSystem
    end

    subgraph "Data & Logging"
        direction TB
        MongoDB["`MongoDB
        (Flows, Executions, Logs)
        Gestito da Mongoose`"]
        Logger["`Logger
        (Winston)`"]
    end
    
    subgraph "Servizi Esterni (via SDKs)"
        direction TB
        LLMs["`LLMs
        (OpenAI, Groq, Anthropic, etc.)`"]
        Tools["`Tools
        (Tavily, Axios)`"]
    end

    %% --- Connessioni ---
    User -- "API Calls" --> API_Gateway
    Scheduler -- "Triggers" --> ExecutionService
    
    FlowService -- "CRUD Operations" --> MongoDB
    ExecutionService -- "CRUD Operations" --> MongoDB
    ExecutionService -- "Logs to" --> Logger
    PluginSystem -- "Logs to" --> Logger
    
    PluginSystem -- "Calls" --> LLMs
    PluginSystem -- "Calls" --> Tools
                

Engine Core Capabilities

A deep dive into the features that make the Flowlitics backend a powerful orchestration tool.

Dynamic Workflow Execution

Manages the entire lifecycle of a flow, handling node execution, state transitions, and conditional logic.

Hybrid Agent Ecosystem

Integrates a wide array of AI agents (OpenAI, Gemini, Claude, etc.) and supports human-in-the-loop tasks.

In-Process Asynchronous Operations

Utilizes an event-driven, non-blocking model within the Express server for efficient handling of I/O operations.

Cron-Powered Scheduling

Automate routine tasks and trigger workflows at precise intervals using a flexible cron-based scheduling system.

Extensible Node System

Easily extend core functionality. Developers can create custom node types with specific logic for unique requirements.

Comprehensive Data Management

Uses MongoDB via Mongoose for storing all workflow definitions, node configurations, and execution logs.

Broad Agent Ecosystem

Seamlessly integrate a diverse range of AI models and human oversight into your workflows for unparalleled flexibility and intelligence.

Human Oversight
OpenAI (GPT)
Google Gemini
Anthropic Claude
Groq API
Mistral
Ollama
Tavily AI

Developer-First RESTful API

Gain programmatic control over every aspect of Flowlitics. Our well-documented API allows for seamless integration with your existing systems.

OpenAPI v3 Documentation

Explore all available endpoints, schemas, and test API calls directly through our interactive Swagger/OpenAPI documentation.

Access API Documentation

The API documentation is served by the backend instance on the /doc/openapi.json path.

Powered by a Modern Stack

The backend is built on a foundation of reliable and scalable technologies.

Node.js Express.js TypeScript MongoDB Mongoose Winston Joi Node-Cron