Flowise

Flowise provides a React-based canvas UI that renders a directed acyclic graph (DAG) of interconnected nodes representing AI components (models, tools, retrievers, memory). Users drag nodes onto the canvas, configure their properties via side panels, and connect edges to define data flow. The canvas maintains node state, validates connections, and serializes the entire workflow graph to JSON for persistence and execution. This eliminates the need to write orchestration code manually.

Flowise abstracts over multiple LLM providers (OpenAI, Anthropic, Ollama, HuggingFace, etc.) through a unified Model Registry that maps provider-specific APIs to a common interface. Credentials are encrypted and stored per-user in the database; at runtime, the system resolves provider credentials from environment variables or the credential store, instantiates the appropriate chat model class, and handles provider-specific configuration (temperature, max_tokens, system prompts). This allows users to swap LLM providers in the UI without code changes.

Flowise provides pre-built Document Loader nodes that ingest data from various sources: PDF files, web pages, CSV/JSON files, text documents, and more. Each loader handles format-specific parsing (PDF extraction, HTML scraping, CSV parsing) and outputs standardized document objects with content and metadata. Users connect a loader to a Vector Store node to index documents for RAG. The system supports both file uploads and URL-based loading, and loaders can be chained to process multiple sources in a single workflow.

Flowise provides Prompt Template nodes that allow users to define LLM prompts with variable placeholders. Users write prompt text with {variable_name} syntax, and the system interpolates values from upstream nodes at execution time. Templates support conditional formatting (if-else logic), loops, and custom formatting functions. This enables dynamic prompt generation based on workflow state without hardcoding prompts. Prompt templates are versioned and can be reused across multiple workflows.

Flowise provides Output Parser nodes that convert unstructured LLM responses into structured data (JSON, CSV, etc.). Users define an output schema (e.g., JSON Schema) and the parser attempts to extract and validate the response against that schema. If parsing fails, the system can retry with a corrected prompt or return an error. This enables workflows to reliably extract structured data from LLM outputs for downstream processing. Parsers support multiple formats: JSON, CSV, key-value pairs, and custom regex patterns.

Flowise implements caching at multiple levels to reduce redundant LLM calls and improve performance. Semantic caching stores LLM responses keyed by input embeddings, so similar queries return cached results without calling the LLM. Exact-match caching stores responses for identical inputs. The system also caches embeddings and vector store queries. Users can enable/disable caching per node, and cache TTL is configurable. This reduces API costs and latency for repeated or similar queries.

Flowise provides Moderation nodes that filter LLM outputs for harmful content (hate speech, violence, sexual content, etc.). The system integrates with moderation APIs (OpenAI Moderation, Azure Content Moderator, etc.) and allows users to define custom moderation rules. If output is flagged as unsafe, the system can reject it, return a sanitized response, or escalate to a human reviewer. This enables workflows to enforce safety policies without manual review.

Flowise provides an Evaluation System that allows users to test workflows against predefined test cases and metrics. Users define test inputs, expected outputs, and evaluation criteria (e.g., semantic similarity, exact match, custom scoring functions). The system runs workflows against test cases, compares outputs to expectations, and generates reports showing pass/fail rates and performance metrics. This enables continuous testing and quality assurance for workflows without manual testing.

Flowise provides pre-built RAG nodes that orchestrate document loading, chunking, embedding, and retrieval. Users connect a Document Loader node (web scraper, PDF parser, etc.) to a Vector Store node (Pinecone, Weaviate, Chroma, FAISS, etc.), which embeds documents using a selected embedding model and stores them. At query time, a Retriever node converts user input to embeddings and performs similarity search, returning relevant documents to feed into an LLM prompt. The system abstracts over multiple vector store backends and embedding models, allowing users to swap storage without workflow changes.

Flowise implements agent execution via a ReAct (Reasoning + Acting) pattern where an LLM iteratively decides which tools to invoke based on a user query. The system maintains an Agent node that wraps an LLM with a tool registry; at each step, the LLM generates a thought and action (tool name + arguments), the system executes the tool, and the result is fed back to the LLM for the next iteration. Tools are registered via a Tool node that defines input schema, execution logic, and output format. The agent continues until it reaches a stopping condition (max iterations, tool returns 'final answer', etc.). This enables complex multi-step reasoning without explicit workflow branching.

Flowise provides memory nodes that persist conversation history across turns using different backend strategies: in-memory (fast but ephemeral), database (persistent across sessions), or vector store (semantic memory for long-context retrieval). Users connect a Memory node to an Agent or Chat node, and the system automatically appends user messages and LLM responses to the memory store. At each turn, the memory is retrieved (optionally filtered by recency or relevance) and injected into the LLM prompt as context. This enables multi-turn conversations without manual context management.

Flowise allows users to define custom logic via Function nodes that execute arbitrary JavaScript/TypeScript code in a sandboxed environment. Users write code that receives input variables from upstream nodes, performs custom transformations or API calls, and returns output to downstream nodes. The system validates function signatures, provides access to a limited set of safe APIs (HTTP requests, JSON parsing, etc.), and isolates execution to prevent code injection or resource exhaustion. This enables workflows to incorporate logic that cannot be expressed via pre-built nodes.

Flowise supports a Queue Mode where workflow execution is decoupled from the main server. When a user triggers a workflow, the request is enqueued (Redis or database-backed) and picked up by worker processes that execute the workflow in parallel. This enables horizontal scaling: multiple workers can process workflows concurrently, and the main server remains responsive to UI requests. Workers pull jobs from the queue, execute the workflow graph, and write results back to the database. The system tracks job status (pending, running, completed, failed) and provides APIs to query results.

Flowise implements streaming for LLM responses, allowing tokens to be sent to the client as they are generated rather than waiting for the full response. The system uses Server-Sent Events (SSE) or WebSocket connections to push tokens in real-time, and the UI displays them incrementally. This applies to both chat responses and agent reasoning steps. Streaming is transparent to the workflow definition; users enable it via configuration, and the execution engine handles buffering and flushing tokens to the client.

Flowise supports multi-tenancy where multiple users can create and execute workflows independently. Each user's workflows, credentials, and conversation history are isolated via user ID checks at the database and API levels. Credentials are encrypted and stored per-user, so one user's API keys cannot be accessed by another. Workflows are scoped to the user who created them, and execution results are stored separately per user. This enables Flowise to be deployed as a shared platform where multiple teams or customers can use the same instance without data leakage.

Flowise allows users to export workflows as JSON files and import them into other Flowise instances. The system also provides a Marketplace where pre-built workflow templates are shared and discoverable. Users can browse templates, import them with one click, and customize them for their use case. Exported workflows include node definitions, connections, and configuration but not credentials (which must be re-entered on import for security). This enables workflow reuse and community sharing.