Flowise: Build Custom AI Chatbots Without Code

Flowise is an open-source, drag-and-drop UI for building LLM-powered applications. Think of it as a visual programming environment for AI — connect nodes representing language models, vector stores, document loaders, and APIs without writing Python. It’s built on LangChain and runs locally or on a server.

What You Can Build with Flowise

• Document Q&A chatbots: upload PDFs, let users ask questions (RAG)
• AI agents with tools: web search, calculator, code execution
• Conversational agents with memory: persistent chat history
• API integrations: connect AI to external services (Notion, Slack, databases)
• Multi-model workflows: chain models, add routing logic

Installation

# Via npm (recommended)
npm install -g flowise
npx flowise start

# Flowise opens at http://localhost:3000

# Docker
docker run -d \
  -p 3000:3000 \
  -v ~/.flowise:/root/.flowise \
  flowiseai/flowise

# With Docker Compose (for persistent data + credentials)

First launch shows the canvas interface — a blank workspace for building flows.

Core Concepts

Nodes

Each node is a component:

• Chat Models: OpenAI GPT-4, Claude, Ollama (local), Mistral
• Embeddings: converts text to vectors (OpenAI, Hugging Face, local)
• Vector Stores: Chroma, Pinecone, Supabase, Qdrant
• Document Loaders: PDF, CSV, Notion, GitHub, YouTube transcripts
• Tools: web search (SerpAPI), calculator, custom API calls
• Memory: Buffer, Summary, Zep, Redis

Chains and Agents

Connect nodes to form a pipeline. Common patterns:

• Conversational Retrieval Chain: document loader → embeddings → vector store → LLM
• ReAct Agent: LLM + tools → autonomous tool use loop

Building a PDF Q&A Chatbot

Step-by-step on the canvas:

1. Add PDF File Loader: drag from sidebar, upload your PDF
2. Add Recursive Character Text Splitter: configure chunk size (1000) and overlap (200)
3. Add Embeddings: OpenAI Embeddings or HuggingFace local embeddings
4. Add Vector Store: Chroma (local, no API key needed)
5. Add Chat Model: OpenAI GPT-4o or Ollama (local)
6. Add Conversational Retrieval QA Chain: connects everything
7. Click Save then Test in the chat panel

The resulting chatbot answers questions about your PDF using RAG (Retrieval-Augmented Generation) — it searches relevant chunks, sends them with the question to the LLM, and generates accurate, cited answers.

Using Local Models with Ollama

Replace OpenAI components with local alternatives:

1. Chat Model node → select Ollama → enter model name (e.g., llama3.1:8b)
2. Embeddings node → select Ollama Embeddings → use nomic-embed-text model
3. Keep Chroma as vector store

Now the entire pipeline runs locally — no API costs, no data leaving your machine.

# Ensure Ollama is running with required models
ollama pull llama3.1:8b
ollama pull nomic-embed-text

Building an Agent with Tools

For autonomous agents that use web search and calculations:

1. Add Chat OpenAI or Ollama
2. Add Tool nodes: Serper API (web search), Calculator
3. Add OpenAI Function Agent or ReAct Agent
4. Connect tools to agent

The agent decides which tools to use based on the user’s question — it might search the web, then calculate, then formulate a final answer.

Chatflows vs. Agentflows

Flowise has two canvas types:

• Chatflows: defined pipelines, predictable execution, faster
• Agentflows: agent orchestration, the agent decides what to do, more powerful but less predictable

Use Chatflows for document Q&A. Use Agentflows for tasks requiring multiple dynamic tool calls.

Sharing and Embedding

Embed in a website

Flowise generates an embed code for any chatflow:

1. Click the chat bubble icon on a saved flow
2. Copy the iframe or script embed code
3. Paste into your website’s HTML

<script type="module">
  import Chatbot from "https://cdn.jsdelivr.net/npm/flowise-embed/dist/web.js"
  Chatbot.init({
    chatflowid: "your-chatflow-id",
    apiHost: "http://your-flowise-server:3000",
  })
</script>

REST API

Every chatflow gets an API endpoint:

curl http://localhost:3000/api/v1/prediction/YOUR_CHATFLOW_ID \
  -H "Content-Type: application/json" \
  -d '{"question": "What does the document say about pricing?"}'

Persistent Memory

Add conversation memory so the chatbot remembers past exchanges:

1. Add Memory node (Buffer Memory or Zep for long-term)
2. Connect to your chain’s memory input
3. Each conversation session maintains context

For cross-session memory (remembers the user across sessions):

• Zep: self-hosted, persists in PostgreSQL
• Redis: fast, in-memory with optional persistence

Flowise Security

For production deployments:

# Set authentication
FLOWISE_USERNAME=admin
FLOWISE_PASSWORD=strongpassword123
npx flowise start

# HTTPS via reverse proxy (Nginx + Certbot)

Never expose an unauthenticated Flowise instance to the internet — it has access to your API keys and documents.

Flowise vs. Alternatives

Tool	Approach	Best For
Flowise	Visual, low-code	Quick prototyping, non-developers
LangChain	Python code	Developers needing full control
LlamaIndex	Python code	Document/RAG-heavy applications
Dify.ai	Visual + cloud	Teams wanting hosted option
Langflow	Visual (Langchain-based)	Developers who want a canvas

Flowise’s strength is rapid prototyping — you can have a working RAG chatbot running in 15 minutes without writing a line of code.