Flowise Chatflow Templates

Enables users to construct conversational AI workflows by dragging components onto a canvas and connecting them via edges, which are then serialized into a directed acyclic graph (DAG) and executed by traversing nodes in dependency order. The system uses a component plugin registry (NodesPool) to dynamically load 100+ pre-built node types (LLMs, memory, tools, retrievers) and executes the graph by resolving variable dependencies across nodes, streaming outputs back to the UI in real-time.

Maintains a centralized model registry that abstracts over 50+ LLM providers (OpenAI, Anthropic, Ollama, HuggingFace, Azure, etc.) through a unified chat model interface. Each provider is implemented as a plugin with credential management, parameter mapping, and streaming support. The system resolves model selection at runtime based on node configuration, handles API key rotation via encrypted credential storage, and normalizes streaming responses across providers with different output formats.

Includes pre-built document loader nodes that support 20+ file formats (PDF, DOCX, XLSX, TXT, Markdown, JSON, CSV, HTML, web URLs) and automatically extract text content. The system handles format-specific parsing (PDF text extraction, DOCX table extraction, HTML DOM traversal) and provides chunking strategies (fixed size, recursive, semantic) to split documents into manageable pieces for embedding. Web scrapers support crawling websites with configurable depth and filtering rules. Loaded documents are automatically passed to embedding and vector store nodes for RAG pipelines.

Abstracts embedding models across 10+ providers (OpenAI, HuggingFace, Ollama, Cohere, Azure, etc.) through a unified embedding interface. Each provider is implemented as a plugin with its own API client, parameter mapping, and caching logic. The system supports batch embedding (multiple documents at once) and caches embeddings to avoid re-computing for identical inputs. Embedding models are selected at the node level, allowing different document sets to use different embedders in the same flow.

Provides prompt template nodes that support variable interpolation (e.g., {user_input}, {context}), conditional logic (if/else based on variables), and dynamic prompt construction. Templates are stored as text with special syntax for variables and conditions, and are compiled at runtime to inject actual values from the flow context. The system supports prompt versioning, testing, and optimization through A/B testing nodes that compare different prompt variants.

Provides comprehensive observability into flow execution through detailed logging, execution traces, and performance metrics. Each node execution is logged with input/output, latency, token usage, and error information. The system supports structured logging (JSON format) that can be exported to external logging systems (ELK, Datadog, etc.). Execution traces show the full DAG traversal with timing information, enabling bottleneck identification and optimization. Token usage is tracked per node and aggregated for cost analysis.

Provides pre-built RAG nodes that orchestrate document ingestion, embedding, and retrieval across 15+ vector store backends (Pinecone, Weaviate, Milvus, Supabase, local in-memory, etc.). The pipeline includes document loaders for 20+ file formats (PDF, DOCX, web pages), chunking strategies (recursive, semantic), and retrievers that support hybrid search (keyword + semantic), metadata filtering, and re-ranking. The system manages vector store connections via credentials, handles embedding model selection (OpenAI, HuggingFace, local), and streams retrieved documents to downstream LLM nodes.

Provides memory nodes that persist conversation history across multiple backend strategies (in-memory, database, vector store, Redis) with configurable retention policies. The system supports different memory types (buffer, summary, entity-based) that integrate with the variable resolution system to inject historical context into LLM prompts. Memory is scoped per conversation session (via session ID) and can be cleared, summarized, or pruned based on token count or time-to-live (TTL) policies.

Enables agents to call external tools and custom functions through a schema-based function registry. Tools are defined as nodes with input/output schemas that are passed to the LLM as function definitions. The system supports native tool calling for OpenAI and Anthropic APIs, and implements a fallback mechanism for other providers using prompt-based function calling. Custom code execution is sandboxed using Node.js VM2 or similar isolation to prevent malicious code from accessing the host system. Tool results are automatically parsed and injected back into the agent loop.

Supports two execution patterns: sequential chains (deterministic step-by-step execution) and agentic loops (LLM-driven reasoning with tool calling and reflection). Agentic flows use a ReAct-style loop where the LLM reasons about the task, selects tools to call, observes results, and iterates until a stopping condition is met. The system manages agent state (current goal, tool history, reasoning trace) and provides hooks for custom stopping criteria, tool selection strategies, and output formatting. Execution is tracked with full observability (logs, traces, token counts) for debugging and optimization.

Enables users to export chatflows and agentflows as JSON definitions that capture the entire graph structure, node configurations, and variable bindings. Exported flows can be imported into other Flowise instances, shared via the built-in marketplace, or version-controlled in git. The system includes a marketplace where users can publish templates (with descriptions, tags, ratings) that others can discover and import with one click. Marketplace templates are validated for security (no hardcoded credentials) and compatibility (required LLM providers, vector stores) before publication.

Provides a built-in chat UI that streams LLM responses token-by-token via WebSockets, enabling real-time progressive rendering of responses. The interface supports markdown rendering, code syntax highlighting, and custom message formatting. Streaming is implemented at the execution engine level, where each node can emit partial results that are immediately sent to the client without waiting for the full response. The system handles connection management, reconnection logic, and message ordering to ensure consistent chat history.

Supports multi-tenant deployments where multiple organizations or users can share a single Flowise instance with isolated data and access controls. Each tenant has its own flows, credentials, documents, and conversation history. The system implements role-based access control (admin, editor, viewer) with fine-grained permissions for creating, editing, deleting, and sharing flows. Credentials are encrypted per-tenant and never shared across tenants. The database schema includes tenant isolation at the row level, ensuring data privacy and compliance.

Provides a queue mode where chatflow and agentflow execution is decoupled from the HTTP request/response cycle. When a user submits a message, it is enqueued (in Redis or database) and processed by a pool of worker processes. Workers execute flows in parallel, with results stored in a database and delivered to clients via polling or WebSocket subscriptions. This architecture enables horizontal scaling by adding more workers, and provides resilience through job retry logic and dead-letter queues for failed executions.