Flowise

Provides a React-based canvas UI where users drag pre-built component nodes (LLM models, chains, tools, memory, vector stores) onto a graph and connect them via edges to define execution flow. The UI architecture uses a node rendering system that maps to a backend component plugin registry, enabling visual construction of complex AI workflows without writing code. Supports real-time node validation and connection constraints based on input/output type compatibility.

Executes a visual flow graph by traversing connected nodes in dependency order, resolving variables at each step, and streaming LLM responses back to the client via Server-Sent Events (SSE). The execution engine handles input/output type coercion, error propagation, and memory context passing between nodes. Supports both synchronous execution for simple chains and asynchronous execution for agent loops with tool calling.

Provides a marketplace where users can publish, discover, and import pre-built flow templates. Flows are exported as JSON with all node configurations, credentials (encrypted), and metadata. Import validates flow compatibility and resolves missing dependencies. Includes flow versioning, ratings, and search functionality. Templates can be cloned and customized. Supports both public marketplace and private organization templates.

Supports multi-tenant deployments where each organization has isolated flows, credentials, and data. Implements role-based access control (RBAC) with roles like Admin, Editor, Viewer. Users are assigned to organizations and inherit role permissions. Credentials are encrypted per-tenant and never shared across organizations. Includes audit logging for compliance. Supports single sign-on (SSO) integration for enterprise deployments.

Integrates multiple document loader types (PDF, TXT, DOCX, CSV, JSON, web scraping) as draggable nodes. Supports configurable parsing strategies (e.g., PDF extraction method, CSV delimiter). Web scraping loader uses Cheerio or Puppeteer for HTML parsing with CSS selector configuration. Documents are chunked using configurable strategies (recursive character split, semantic split). Metadata is extracted and preserved. Supports batch document processing and incremental updates.

Provides tools for evaluating flow outputs against expected results using configurable metrics (BLEU, ROUGE, semantic similarity, custom functions). Supports batch evaluation of flows with multiple test cases, result aggregation, and performance reporting. Includes A/B testing support for comparing flow variants. Results are stored and visualized in dashboards. Integrates with LLM-as-judge for semantic evaluation.

Provides a prompt node type where users define LLM prompts with configurable variables (user input, flow context, node outputs). Supports prompt versioning and A/B testing of prompt variants. Includes prompt optimization suggestions based on LLM performance metrics. Variables are interpolated using a custom syntax (e.g., {variable_name}). Supports system prompts, user prompts, and assistant prompts for multi-turn conversations. Includes prompt caching for cost optimization.

Extends chatflow execution to support agent semantics: LLM models can invoke tools (function calls), receive tool results, and loop until reaching a terminal state. The agentflow engine manages the agent loop, tool registry binding, and output parsing. Supports sequential agent flows where multiple agents collaborate, with memory passing between agent invocations. Integrates with LangChain's AgentExecutor and custom agent implementations.

Abstracts LLM model selection across multiple providers (OpenAI, Anthropic, Ollama, HuggingFace, Azure, etc.) through a model registry that loads provider-specific implementations. Credentials are encrypted and stored per-user, with secure injection into model instances at runtime. Supports model parameter configuration (temperature, max_tokens, system prompts) via UI forms generated from JSON schemas. Handles provider-specific quirks (token counting, streaming format differences) transparently.

Integrates multiple vector store backends (Pinecone, Weaviate, Chroma, Milvus, Supabase, etc.) as draggable nodes in the flow. Supports document ingestion with configurable chunking strategies, embedding model selection, and metadata filtering. The RAG pipeline node retrieves semantically similar documents and injects them into LLM context. Includes record manager for deduplication and update tracking. Handles streaming document uploads and batch indexing.

Allows users to define custom JavaScript/Python functions as nodes in the flow, executed in a sandboxed environment with access to node inputs and flow context. Functions receive typed inputs, can perform arbitrary transformations, and return outputs for downstream nodes. Includes syntax validation, error handling, and execution timeout protection. Supports importing common libraries (lodash, axios) within sandbox constraints.

Provides multiple memory node types (Buffer Memory, Summary Memory, Entity Memory) that persist conversation history across chat turns. Memory nodes are draggable onto the canvas and automatically inject previous messages into LLM context. Supports configurable memory size limits, summarization strategies, and entity extraction. Integrates with database storage for multi-turn conversations and session management. Handles memory clearing and reset operations.

Automatically generates REST API endpoints from chatflows and agentflows, with configurable HTTP methods, request/response schemas, and authentication. Each flow becomes a callable API with OpenAPI/Swagger documentation auto-generated from node schemas. Supports API key authentication, rate limiting, and CORS configuration. Endpoints are immediately deployable without additional code; documentation is served at /api-docs.

Provides a pre-built, embeddable JavaScript widget (agentflow package) that can be dropped into any website to expose a chatflow as a floating chat interface. Widget includes customizable styling (colors, fonts, branding), conversation history UI, file upload support, and SSE streaming for real-time responses. Widget communicates with Flowise backend via API, handling session management and CORS. Supports both iframe and direct DOM injection modes.

Implements a distributed execution model using Bull queue (Redis-backed) where flow execution jobs are enqueued and processed by worker processes. Supports multiple worker instances for horizontal scaling, job retry logic with exponential backoff, and job status tracking. Workers are stateless and can be deployed independently. Includes monitoring dashboard for queue health, job history, and worker status. Enables long-running flows without blocking the main server.