Flowise Chatflow Templates

Enables users to construct conversational AI workflows by dragging pre-built component nodes onto a canvas and connecting them via edges. The system parses the resulting directed acyclic graph (DAG), resolves variable dependencies across nodes, and executes the flow sequentially or in parallel based on connection topology. Uses a component plugin system where each node type (LLM, retriever, tool, etc.) implements a standardized interface that Flowise introspects to expose configurable parameters in the UI.

Maintains a centralized registry of supported LLM providers (OpenAI, Anthropic, Ollama, HuggingFace, etc.) with provider-specific chat model implementations. Credentials are stored encrypted in the database and abstracted behind a credential manager, allowing users to swap providers without modifying flow logic. Each provider implements a standardized chat interface that Flowise uses to normalize API calls, streaming responses, and error handling across heterogeneous LLM backends.

Implements a queue-based execution model where flow execution requests are enqueued and processed by a pool of worker processes. This decouples flow submission from execution, enabling horizontal scaling by adding more workers. Long-running flows don't block the API server, improving responsiveness. The system uses a message queue (Redis, Bull, etc.) to distribute work across workers. Each worker executes flows in isolation, with its own LLM connections and memory state. Results are stored in a database and retrieved asynchronously via polling or webhooks.

Provides an embeddable JavaScript widget that can be integrated into third-party websites to expose a Flowise chatflow as a chat interface. The widget communicates with the Flowise API via REST or WebSocket, sending user messages and receiving responses. The widget handles UI rendering (chat bubbles, input box, etc.), message history, and streaming responses. It can be customized with CSS variables for branding (colors, fonts, etc.) and configured with flow-specific parameters (flow ID, API endpoint, etc.). The widget is self-contained and doesn't require the host website to have any backend integration.

Provides an evaluation system for testing flows against datasets and computing metrics (accuracy, latency, cost, etc.). Users can define test cases with inputs and expected outputs, then run flows against the dataset and compare results. The system computes metrics like token usage, execution time, and semantic similarity between outputs and expected results. Evaluation results are stored and can be compared across flow versions, enabling A/B testing of different configurations. The framework supports custom evaluation metrics via user-defined functions.

Implements streaming response handling for long-running operations (LLM generation, tool execution, etc.) using WebSocket or Server-Sent Events (SSE). Clients receive response tokens or intermediate results in real-time as they are generated, rather than waiting for the entire response to complete. The system buffers tokens on the server and sends them to clients in configurable chunk sizes. Streaming is transparent to the flow definition; users don't need to explicitly enable streaming for each node.

Provides pre-built nodes for document ingestion, embedding generation, and semantic retrieval that compose into a RAG pipeline. Supports multiple vector store backends (Pinecone, Weaviate, Milvus, Supabase, in-memory) with a standardized retriever interface. Documents are chunked, embedded using configurable embedding models, and stored with metadata. At query time, user input is embedded and used to retrieve semantically similar documents, which are then passed as context to the LLM node. The system includes a record manager for deduplication and update tracking.

Manages conversation history across multiple memory backends (in-memory, database, Redis, Upstash) with configurable retention policies. Supports memory types including buffer memory (last N messages), summary memory (LLM-generated summaries of past conversations), and entity memory (tracked entities across turns). Memory nodes are inserted into the flow and automatically populate the LLM context with historical messages. The system handles memory clearing, pruning, and multi-turn conversation state without requiring explicit session management code.

Enables flows to invoke external tools and execute custom code through a tool architecture that supports both pre-built integrations (web search, calculator, database queries) and user-defined functions. Custom functions are executed in a sandboxed environment with restricted access to system resources. Tools are registered in the component system and exposed to agent nodes, which can decide when to call them based on LLM reasoning. Tool outputs are automatically parsed and fed back into the LLM for further reasoning, enabling agentic loops.

Provides agent node types (ReAct, conversational, sequential) that implement reasoning loops where the LLM decides which tools to call, observes results, and iterates until a goal is reached. Agents are configured with a set of available tools, a reasoning strategy, and termination conditions (max iterations, goal reached, etc.). The system handles the agentic loop internally: LLM generates tool calls, tools are executed, results are fed back to the LLM, and the loop continues. Sequential agent flows allow multiple agents to be chained together, with one agent's output feeding into the next.

Provides document loader nodes for ingesting content from multiple sources (PDF, markdown, HTML, web pages, databases, APIs) and converting them into a standardized document format. Each loader handles source-specific parsing (PDF text extraction, HTML tag stripping, etc.) and outputs documents with metadata (source URL, page number, chunk index, etc.). Loaders can be chained with text splitters to chunk documents into smaller pieces suitable for embedding and retrieval. The system supports both batch ingestion (load all documents at startup) and incremental ingestion (load documents on-demand).

Provides prompt template nodes that support variable interpolation, conditional logic, and dynamic context injection. Templates use a simple syntax (e.g., `{variable_name}`) to reference flow variables, LLM outputs, and tool results. Templates can include conditional blocks (if/else) to customize prompts based on runtime values. The system resolves variables at execution time by traversing the flow graph and extracting outputs from upstream nodes. Prompt templates are stored as text nodes and can be edited visually or via a rich text editor with syntax highlighting.

Enables users to export chatflows and agentflows as JSON definitions that can be version-controlled, shared, or imported into other Flowise instances. The export format includes node configurations, connections, and credentials (encrypted). A marketplace allows users to publish and discover community-built templates, with ratings and usage statistics. Templates can be imported with a single click, automatically creating all nodes and connections. The system validates imported flows for compatibility with the current Flowise version and alerts users to missing dependencies (e.g., unavailable LLM providers).

Supports multi-tenant deployments where multiple users or organizations can create and manage their own flows within a single Flowise instance. Each tenant has isolated flows, credentials, and chat histories. API keys are generated per user or organization, enabling programmatic access to flows via REST endpoints. The system enforces access control at the database level, preventing users from accessing other tenants' data. Credentials are encrypted and scoped to the tenant, preventing credential leakage across tenants.