Flowise Self-Host Guide: Build LLM Apps Visually Without Writing a Single Line of Glue Code

Building an LLM app usually means stitching together API calls, writing prompt management code, handling memory, wiring up vector stores, and building a retrieval pipeline — before you've shipped a single user-facing feature. Flowise skips all of that. It's an open-source visual builder for LLM workflows: drag in nodes for models, memory, retrievers, tools, and chains, connect them on a canvas, and get a working chatbot or AI pipeline with a REST API endpoint. This Flowise self-host guide walks you through deploying it on your own server and building real LLM apps from scratch.

Prerequisites

• A Linux server or local machine (Ubuntu 20.04+ recommended)
• Docker Engine and Docker Compose v2 installed — or Node.js 18+ if you prefer a direct install
• At least 1GB RAM — Flowise itself is lightweight; your LLM provider does the heavy lifting
• An API key for at least one LLM provider (OpenAI, Anthropic, etc.) or a local Ollama instance
• Port 3000 available (or any port you choose)
• A domain name for production use (optional for local testing)

Confirm your environment:

docker --version
docker compose version
free -h

# Check port 3000 is available
sudo ss -tlnp | grep 3000

What Is Flowise and What Can You Build With It?

Flowise is an open-source LLM application builder built on LangChain.js. It gives you a visual drag-and-drop interface for constructing chains, agents, and RAG pipelines — the same things you'd build in code, but wired together on a canvas. Every flow you build gets an API endpoint automatically.

What You Can Build

• RAG chatbots — upload documents, index them into a vector store, and build a chatbot that answers questions from your own content
• Conversational agents — LLM agents with tool use: web search, calculators, API calls, database lookups
• Multi-chain pipelines — sequential and conditional chains where the output of one LLM call feeds the next
• Custom document QA — PDF, Word, Markdown, web scrape, Notion, Confluence — all supported as document loaders
• API integrations — HTTP request nodes let you call any external API from within a flow
• Embedded chatbots — Flowise generates a JavaScript embed snippet so you can drop a chat widget into any website

Flowise vs. Dify vs. LangChain Code

Dify is more opinionated and product-focused — better for teams who want a full AI platform with user management and prompt versioning. Flowise is more flexible and developer-centric — better for rapidly prototyping LangChain patterns visually before deciding whether to implement them in code. They complement each other more than they compete.

Installing and Running Flowise

Option 1: Docker Compose (Recommended for Production)

Create a project directory and Compose file:

mkdir -p ~/flowise
cd ~/flowise

# docker-compose.yml
version: '3.8'

services:
  flowise:
    image: flowiseai/flowise:latest
    container_name: flowise
    restart: unless-stopped
    ports:
      - "3000:3000"
    environment:
      - PORT=3000
      - FLOWISE_USERNAME=${FLOWISE_USERNAME}
      - FLOWISE_PASSWORD=${FLOWISE_PASSWORD}
      - APIKEY_PATH=/root/.flowise
      - SECRETKEY_PATH=/root/.flowise
      - LOG_PATH=/root/.flowise/logs
      - DATABASE_PATH=/root/.flowise
      - DATABASE_TYPE=sqlite
      # Uncomment for PostgreSQL (recommended for production):
      # - DATABASE_TYPE=postgres
      # - DATABASE_HOST=postgres
      # - DATABASE_PORT=5432
      # - DATABASE_USER=${POSTGRES_USER}
      # - DATABASE_PASSWORD=${POSTGRES_PASSWORD}
      # - DATABASE_NAME=flowise
    volumes:
      - flowise_data:/root/.flowise
    entrypoint: /bin/sh -c "sleep 3; flowise start"

volumes:
  flowise_data:

Create your .env file:

# .env
FLOWISE_USERNAME=admin
FLOWISE_PASSWORD=a-strong-password-here

# For PostgreSQL backend (production):
# POSTGRES_USER=flowise
# POSTGRES_PASSWORD=a-strong-db-password

Start Flowise:

docker compose up -d
docker compose logs -f flowise

Watch for Flowise Server started at port 3000 in the logs. Then open http://localhost:3000 and log in with your credentials.

Option 2: Node.js Direct Install (Local Development)

If you want to run Flowise directly without Docker — useful for local development where you want to install custom nodes:

# Install globally
npm install -g flowise

# Start with basic auth
FLOWISE_USERNAME=admin FLOWISE_PASSWORD=yourpassword npx flowise start

# Or start without auth for local-only use
npx flowise start --port 3000

Putting Flowise Behind Nginx with HTTPS

For production access over a clean domain:

server {
    listen 80;
    server_name flowise.yourdomain.com;
    return 301 https://$host$request_uri;
}

server {
    listen 443 ssl;
    server_name flowise.yourdomain.com;

    ssl_certificate /etc/letsencrypt/live/flowise.yourdomain.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/flowise.yourdomain.com/privkey.pem;

    # Increase for document uploads
    client_max_body_size 50M;

    location / {
        proxy_pass http://localhost:3000;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection 'upgrade';
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_cache_bypass $http_upgrade;
        # Required for streaming responses
        proxy_read_timeout 300s;
        proxy_buffering off;
    }
}

sudo nginx -t && sudo systemctl reload nginx
sudo certbot --nginx -d flowise.yourdomain.com

Connecting LLM Providers and Models

Adding Credentials

In Flowise, credentials are stored centrally and referenced by name in your flows — your actual API keys never appear in the canvas. Go to Credentials → Add Credential to add your LLM provider keys before building anything.

Supported providers include OpenAI, Anthropic, Google Gemini, Azure OpenAI, Mistral, Cohere, HuggingFace, and any OpenAI-compatible API (including LiteLLM and Ollama).

Using Local Models via Ollama

To use Ollama models inside Flowise flows, add an Ollama node to your canvas. Set the base URL to your Ollama instance:

# If Ollama is running on the same host as Flowise (Docker)
# Use the Docker bridge IP:
http://172.17.0.1:11434

# If Flowise is running via Node.js directly on the host:
http://localhost:11434

# If Ollama is on a separate server:
http://your-ollama-server-ip:11434

# Confirm Ollama is reachable from inside the Flowise container:
docker exec flowise curl -s http://172.17.0.1:11434/api/tags | jq '.models[].name'

Building Your First Flows

Simple LLM Chain

The most basic flow: a prompt template connected to an LLM. Go to Chatflows → Add New. On the canvas:

1. Drag in a ChatOpenAI node (or whichever model you're using) — select your saved credential
2. Drag in a ChatPromptTemplate node — write your system prompt and define input variables using {variable_name} syntax
3. Drag in a LLM Chain node — connect ChatPromptTemplate to its Prompt input and ChatOpenAI to its Language Model input
4. Click Save, then Test the chat in the right panel

That's a working LLM chain. Every input variable in your prompt template becomes a field in the API request body automatically.

RAG Chatbot with Document Upload

Building a chatbot that answers from your own documents takes five node types:

1. Document Loader — PDF File, Text File, Web Scraper, Confluence, Notion, etc.
2. Text Splitter — Recursive Character Text Splitter (chunk size 1000, overlap 200 is a good start)
3. Embeddings — OpenAI Embeddings, or local via Ollama Embeddings
4. Vector Store — In-Memory (for testing), Qdrant, Weaviate, Pinecone, pgvector (for production)
5. Conversational Retrieval QA Chain — ties the retriever and LLM together with conversation memory

Wire them: Document Loader → Text Splitter → Vector Store ← Embeddings; Vector Store (as retriever) → Conversational Retrieval QA Chain ← ChatOpenAI.

Upload your documents via the chatflow's document upload button, then start asking questions. The retriever fetches the most relevant chunks and the LLM generates an answer grounded in your content.

Agent with Tool Use

For an LLM that can take actions — search the web, call APIs, run calculations — use the Tool Agent node. Connect it to:

• A chat model (GPT-4o or Claude recommended for tool use)
• A Buffer Memory node for conversation history
• Tool nodes: SerpAPI (web search), Calculator, Custom Tool (HTTP request to any API)

The Custom Tool node lets you define any HTTP endpoint as a tool the agent can call. Give it a name, description, and the API schema — the LLM decides when to use it based on the user's query.

Using the Flowise API

Every saved chatflow in Flowise has a REST API endpoint. Find the API URL under API Endpoint (the </> button in the chatflow header).

Basic Chat API Call

# Call a chatflow via REST API
curl -X POST https://flowise.yourdomain.com/api/v1/prediction/YOUR_CHATFLOW_ID \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_FLOWISE_API_KEY' \
  -d '{
    "question": "What is our refund policy?",
    "overrideConfig": {
      "sessionId": "user-session-123"
    }
  }' | jq .text

Streaming Response

# Streaming via SSE
curl -X POST https://flowise.yourdomain.com/api/v1/prediction/YOUR_CHATFLOW_ID \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_FLOWISE_API_KEY' \
  -H 'Accept: text/event-stream' \
  -d '{
    "question": "Explain how RAG works",
    "streaming": true
  }'

Generating and Managing API Keys

Go to API Keys in the Flowise sidebar to generate keys. You can create multiple keys and restrict them to specific chatflows — useful for giving different apps or team members their own keys without sharing admin credentials:

# Test your API key
curl https://flowise.yourdomain.com/api/v1/chatflows \
  -H 'Authorization: Bearer YOUR_FLOWISE_API_KEY' | jq '[.[] | {id: .id, name: .name}]'

# Upload a document to a chatflow via API
curl -X POST https://flowise.yourdomain.com/api/v1/vector/upsert/YOUR_CHATFLOW_ID \
  -H 'Authorization: Bearer YOUR_FLOWISE_API_KEY' \
  -F 'files=@/path/to/your/document.pdf'

Embedding a Chat Widget

Flowise generates an embeddable chat widget for any chatflow. Go to Configuration → Embed in the chatflow editor and copy the script tag. Drop it into any HTML page:

<!-- Flowise embed widget -->
<script type="module">
  import Chatbot from 'https://cdn.jsdelivr.net/npm/flowise-embed/dist/web.js'
  Chatbot.init({
    chatflowid: 'YOUR_CHATFLOW_ID',
    apiHost: 'https://flowise.yourdomain.com',
    chatflowConfig: {
      // Optional: override model params, session ID, etc.
    },
    theme: {
      button: { backgroundColor: '#6366f1' },
      chatWindow: {
        welcomeMessage: 'Hi! How can I help you today?',
        backgroundColor: '#ffffff',
        fontSize: 16
      }
    }
  })
</script>

Tips, Gotchas, and Troubleshooting

Flow Not Saving or Canvas Disappears

This usually means a volume permission issue or a SQLite write failure. Check container logs:

docker logs flowise --tail 50 | grep -i error

# Check volume permissions
docker exec flowise ls -la /root/.flowise

# Fix if needed
docker exec flowise chown -R root:root /root/.flowise

LLM Responses Timing Out on Long Chains

Complex multi-step flows can take longer than Nginx's default proxy timeout. The Nginx config above already sets proxy_read_timeout 300s — confirm that's in place. Also check the LLM node's timeout setting in the Flowise UI (Advanced settings on the model node).

Vector Store Not Persisting Between Restarts

The In-Memory vector store is wiped on every container restart — it's for testing only. For production RAG apps, use a persistent vector store: Qdrant, Weaviate, or pgvector. All three have Docker images you can run on the same server:

# Add Qdrant to your docker-compose.yml
  qdrant:
    image: qdrant/qdrant:latest
    container_name: qdrant
    restart: unless-stopped
    volumes:
      - qdrant_data:/qdrant/storage
    ports:
      - "6333:6333"

# In Flowise Qdrant node:
# Qdrant Server URL: http://qdrant:6333  (internal Docker network)
# Collection Name: your-collection-name

Updating Flowise

docker compose pull flowise
docker compose up -d flowise

# Verify new version
docker logs flowise --tail 5 | grep -i version

# Check release notes before updating — node schemas occasionally change:
# https://github.com/FlowiseAI/Flowise/releases

Pro Tips

• Export flows as JSON and commit to Git — go to the chatflow settings and export. Treat your flows like code: version them, review changes, and restore from history when a change breaks something.
• Use Flowise Marketplace for starting points — the built-in Marketplace (under Marketplaces in the sidebar) has dozens of pre-built flows you can import and modify. Don't start from scratch when someone has already built a working RAG template.
• Separate credential sets by environment — create different API key credentials named OpenAI-Dev and OpenAI-Prod. Swap them per flow so development traffic doesn't burn your production quota.
• Use Upsert mode for document updates — when you update a document in a RAG flow, use the Upsert API endpoint rather than re-creating the vector store from scratch. It updates only changed chunks.
• Test flows with the built-in chat panel before exposing via API — the right-side chat panel in the canvas editor lets you test with real inputs without touching the API. Catch prompt and retrieval issues before they reach production.

Wrapping Up

A complete Flowise self-host setup gives you a visual LLM development environment where you can prototype RAG apps, agents, and multi-step chains in minutes instead of days — then expose them as clean REST APIs that any frontend or backend can call.

Start with the Docker Compose deployment, connect your LLM provider credentials, and build your first RAG chatbot using a PDF you already have. Once that pattern clicks, the node library opens up: custom tools, agent loops, conditional chains, webhook triggers. Flowise covers the plumbing so you can focus on the logic that actually matters for your use case.