No local installation needed
Start Flowise instantly in the browser without installing anything
Track 7 · Advanced
7.3
Flowise
Drag boxes on a canvas to build a chatbot, a RAG bot or a multi-agent flow
1Overview
Flowise builds LLM apps by wiring nodes on a visual canvas — no code needed to get a working chatbot grounded in your own PDFs. It covers the whole arc: a first Chatflow, retrieval over your documents, giving the agent tools, an Agentflow where several agents share one job, a human-in-the-loop step, then tracing and evaluation before you embed or self-host it.
Flowise is the no-code path: drag nodes onto a canvas, wire them together, and you have a working chatbot or RAG bot. It goes further than a demo — tools, multi-agent Agentflows, human-in-the-loop, tracing, then embed or self-host.
1.1Before you start
1.2After this chapter you can
→Build a working chatbot on the Flowise canvas without writing code
→Ground an agent in your own PDFs with a retrieval Chatflow
→Give an agent tools, and orchestrate several agents in one Agentflow
→Pause a flow for human approval before it acts
→Trace and evaluate a run, then publish the flow as a widget or an API
1.3How do I create a chatbot?
Drag a chat node onto the canvas, connect it to a language model node, and configure the input and output settings; the flow runs instantly without writing code.
1.4Can I use my own documents?
Yes—add a document loader node, point it at your PDFs, then wire a retrieval node into the chatflow so the assistant can answer questions grounded in those files.
1.5What if I need multiple agents?
Build an Agentflow by placing several agent nodes, linking them to share tasks, and optionally insert a human‑in‑the‑loop node for review before final responses.
2Lessons 7
2.1 Create your first AI agent flow
Flowise lets you build LLM applications by wiring nodes on a visual canvas; the simplest is a Chatflow, which connects a chat model to optional components.
Create a free Flowise Cloud account and assemble a basic Chatflow that responds in the chat panel
Try
Drag a Chat Model node onto the canvas, connect an OpenAI chat node to it, open the chat panel and ask: "Explain what retrieval-augmented generation is in two sentences."Open flowiseai.com, start a free Flowise Cloud account, and click New Chatflow — you build and test entirely in the browser.
- Visit flowiseai.com and sign up for a free Flowise Cloud account
- Click New Chatflow to open a blank canvas
- Drag a Chat Model node onto the canvas and paste your API key into its configuration
- Open the chat panel and send a prompt to see the agent reply
- You'll see A two‑node flow appears on the canvas and the chat panel returns an answer to your question
- Takeaway Connecting nodes on the canvas is all that’s required to get a working AI agent
- Check You dropped a Chat Model node on the canvas but it does not answer. What configuration element is most often missing?
- Cost Flowise Cloud Free = $0/month (2 flows & assistants, 100 predictions/month, 5MB storage). Self-hosting the open-source version is free. On every plan you separately pay your own LLM API usage.
2.2 Build a chatbot that answers from your PDF
RAG in Flowise uses four nodes: a PDF File loader, a vector store, and a chat model that only answers from retrieved passages.
Do this first Create your first AI agent flow
Build a chatbot that answers solely from the content of an uploaded PDF
Try
Summarize the main method in this document.In a New Chatflow, drag in a PDF File loader and upload one paper, connect an OpenAI chat node plus a vector store, then open the chat panel and ask the question above.
- Create a New Chatflow and drag a PDF File loader onto the canvas; upload your document
- Add a Vector Store node and connect it to the PDF loader
- Connect an OpenAI Chat Model node, open its chat panel, and ask a question
- You'll see The answer is drawn from passages in your uploaded PDF, showing a document‑grounded Q&A bot
- Takeaway RAG lets you turn any PDF into a searchable knowledge base for accurate answers
- Check Why does grounding the bot in your PDF reduce hallucinations but not eliminate them completely?
- Cost Within the Free plan's 100 predictions/month and 5MB storage; each answer also spends your own LLM + embedding API usage.
2.3 Create a Chatflow assistant that uses tools and documents
A tool is a thing the agent may call — a search, a calculator, an API — and giving the agent tools is what turns it from something that talks into something that acts. The model decides whether to call one; you decide which ones exist.
Do this first Build a chatbot that answers from your PDF
Build a single‑agent chat assistant that can call external tools and retrieve information from your documents
Try
When the user asks a factual question, search the web and cite your source; otherwise answer from the uploaded documents.Flowise has three builder types — Assistant, Chatflow, and Agentflow. A Chatflow is a single agent with tool calling and RAG; that's what you use here.
- Start a Chatflow and select your chat model as the agent’s brain
- Add a Tool node and link it to the agent so it can perform actions
- Open the Chat panel, ask a question that requires the tool, and watch the assistant call the tool and respond
- You'll see A chat assistant that automatically invokes a tool when needed and otherwise answers using the supplied documents
- Takeaway A Chatflow becomes an autonomous agent once you connect tools and data sources to it
- Check The assistant answered from memory instead of calling your tool. Name two things that make a model reach for a tool.
- Cost Runs against your 100 predictions/month on the Free plan; tool-calling turns spend extra LLM tokens billed by your provider.
2.4 Orchestrate multiple AI agents with an Agentflow
An Agentflow is the visual orchestrator for multi‑agent workflows; each node can be an agent, a tool, or a processing step, and connections define the hand‑off order.
Do this first Create a Chatflow assistant that uses tools and documents
Build a coordinated workflow where several agents pass work to each other to complete a multi‑step task
Try
From a Start node, route to a Search Agent that gathers facts and a Get Request node that fetches data, then pass both to a Summarize node that writes the final answer.Use the third builder type, Agentflow — Flowise's canvas for multi-agent orchestration, where each node is a step or an agent and the connections set the order.
- 1 Search Agent button performs web search step
- 2 Start button entry point of the agentflow
Best viewed on desktop — tap Enlarge to read the numbered controls.
- Create an Agentflow and add a Start node as the entry point
- Insert a Search Agent, a Get Request tool, and a Summarise step, then connect them so work flows sequentially
- Run the flow from the chat panel and watch each agent execute its part and hand off
- You'll see The canvas shows a Start node leading to a Search Agent and a Get Request tool, converging on a Summarise step that outputs the final answer
- Takeaway Wire multiple agents together in an Agentflow to manage complex hand‑offs
- Check Why does a three‑agent Agentflow cost several times more per run than accomplishing the same job with a single Chatflow?
- Cost Every agent step is its own model call, so a multi-agent run spends more predictions and tokens than a single Chatflow — plan the flow before you run it repeatedly.
2.5 Pause an agent for human approval
A Human-in-the-loop node pauses execution and presents a review card where a person can approve, reject or edit the agent’s output before it proceeds.
Do this first Orchestrate multiple AI agents with an Agentflow
Stop an autonomous step until a human reviews and decides to proceed, reject or modify the result
Try
Before sending the drafted message, ask the user to Proceed or Reject, and let them give feedback on the last assistant message.Flowise has built-in human-in-the-loop review — add it to a flow so the run stops for sign-off instead of acting unsupervised.
- Open your flow and insert a human‑in‑the‑loop node before the step you want to control
- Run the flow; when it reaches the review node, click Proceed to continue or Reject to halt
- If you choose Reject, type feedback in the box and resubmit so the agent revises its output
- You'll see The flow halts on a review card showing Proceed and Reject buttons together with a feedback textbox
- Takeaway Human‑in‑the‑loop adds supervisory control to any automated action
- Check Where should an approval node be placed in a flow – before the risky step or after it, and why?
- Cost Review adds no model cost while it waits; you only spend tokens when the agent resumes or revises after your feedback.
2.6 Inspect an agent's execution and assess its performance
A trace records every step of a run, including inputs, outputs, duration and token usage; Evaluations add scoring against expected answers to measure quality over time.
Do this first Pause an agent for human approval
Inspect each step an agent took, view its resource use, and compare run quality across iterations
Try
Open the trace for the last run and check which agent handled each step, how long it took, and how many tokens it used.Flowise includes tracing/analytics and Evaluations & Metrics (the latter is on every plan, including Free) for monitoring runs.
- Run a multi‑step Agentflow and open its execution trace to view each step’s input and output
- Read the per‑step timing and token counts to identify slow or costly operations
- Use Evaluations & Metrics to score runs against expected answers and verify whether changes improve performance
- You'll see A trace listing every step of a run with its inputs, duration and token usage
- Takeaway You can only optimise what you can observe – traces and evaluations make agent behaviour measurable
- Check You changed a prompt and the answer looks better. What evidence would convince you that the improvement is real?
- Cost Tracing, analytics and Evaluations & Metrics are included on the Free plan; running the evaluations themselves spends normal model tokens.
2.7 Publish your agent as a widget or API
Publishing exposes a flow as an embeddable chat widget, an API endpoint, or a self‑hosted service, allowing real users to interact with the agent from a website or code.
Do this first Inspect an agent's execution and assess its performance
Deploy the finished agent so it can be used on a web page or called from application code
Try
Publish this Chatflow as an embeddable chat widget, then grab its API endpoint to call from a script.A finished Flowise agent can ship as an embeddable chat widget or be called via API, CLI, and TS/Python SDKs — and you can self-host it, even air-gapped.
- Publish the flow as an embeddable chat widget and copy the generated snippet into your site’s HTML
- Invoke the agent via the API from your application code
- Choose Flowise Cloud for managed hosting or select self‑host for an on‑premises deployment
- You'll see Your agent appears as a live chat widget on the page and responds to requests sent to its API endpoint
- Takeaway Agents move from prototype to production by being served as widgets or callable APIs on cloud or self‑hosted infrastructure
- Check Which publishing method would you choose for a chatbot handling confidential research data, and why?
- Cost Publishing is included on every plan; you stay within your plan's prediction limits (Free 100/mo, Starter $35/mo 10,000/mo, Pro $65/mo 50,000/mo) plus your own LLM API usage. Self-hosting the open-source version is free.
3FAQ, Tips & How-to 3
one problem, one solution, one action
The same set on /recipes, filtered by tool and role.
4Videos 3
Build RAG AI Assistant with Flowise AI
The deep build once the basics click. Watch when you want a Flowise assistant grounded in your own documents.
Build Your First AI Agent with Flowise | Create Your First AI Agent 🤖 🚀
The 'blank canvas to working agent' walkthrough. Start here to learn the node types by building.
Stop Learning n8n in 2026... Learn THIS Instead
Best framing video if you already know n8n — it tells you when to reach for Flowise's LLM-first canvas instead.
5FAQ 6
What is Flowise and what is it for?
Flowise is an open-source platform for building AI agents and LLM workflows visually, instead of writing code. You assemble apps by dragging boxes called nodes onto a canvas and connecting them, so you can see exactly how information flows. It is built for things like document-aware chatbots (RAG over your own PDFs), single chat assistants that can call tools, and multi-agent workflows where several agents hand work to each other. It connects to 100+ sources, tools, vector databases and memories, and major LLM and embedding providers, so most of the work is choosing and wiring nodes rather than programming.
How do I publish my finished agent for real users?
A finished flow can ship two main ways. As an embeddable chat widget: Flowise gives you a small script snippet that imports the flowise-embed module and initializes it with your chatflow ID and API host, which you paste between the body tags of your web page; the widget is themeable. Or programmatically: each flow is exposed via an API, a CLI, and TypeScript and Python SDKs, so other software can call it. You choose where it runs: Flowise Cloud (managed) or self-host the open-source version, including fully air-gapped for sensitive data. Publishing is included on every plan, within your plan's prediction limits.
What are Assistant, Chatflow and Agentflow?
These are Flowise's three builder types. Assistant is the most beginner-friendly way to create an AI agent: a chat assistant with instruction-following, tool use and RAG. Chatflow is for single-agent systems, chatbots and simpler LLM flows, with support for techniques like Graph RAG and rerankers. Agentflow is the superset of the other two and is where you do multi-agent orchestration: several agents and steps wired together on a canvas, where the connections set the order of work. A good progression is to start with a Chatflow assistant, then move to an Agentflow once one agent is not enough for the task.
How do I build a chatbot that answers from my own PDFs?
This is RAG (retrieval-augmented generation) and it is Flowise's sweet spot. Create a New Chatflow, drag a PDF File loader onto the canvas and upload your document. Add a vector store node and connect it: this indexes your PDF so the model can retrieve the relevant passages before answering. Then connect a chat-model node (for example OpenAI), open the chat panel, and ask something like 'Summarize the main method in this document.' The reply should be grounded in your uploaded file, not generic knowledge. You wire the vector store and embeddings visually instead of coding them, though those concepts do have a real learning curve.
Can I keep a human in the loop before the agent does something risky?
Yes, Flowise has built-in human-in-the-loop review. You add a review step to a flow before the action you do not want fully automated, such as sending an email or finalising an answer. When the run reaches it, the flow pauses and shows the proposed output with Proceed and Reject controls, plus a box to give feedback on the last assistant message. Approving lets it continue; rejecting with a note sends the agent back to revise. The review adds no model cost while it waits, you only spend tokens when the agent resumes. This is how you ship agents you can trust on real tasks instead of running them unsupervised.
How do I see what my agent did and whether it is working well?
Flowise includes tracing and analytics plus Evaluations and Metrics, and the latter is on every plan including Free. After a run you open its execution trace: a step-by-step view from Start through each agent to the final answer, showing each step's inputs, outputs, duration and token count. That is how you find a slow or expensive step, or debug a wrong answer. Evaluations and Metrics let you score runs against expected answers so you can tell whether a change to the flow genuinely improved it rather than just feeling better. Tracing and evaluations are free; running the evaluations themselves spends normal model tokens.
6Glossary 22 terms
Show the 22 terms
Flowise
Chatflow- A visual builder in Flowise for creating single-agent chatbots and simple LLM workflows by connecting nodes on a drag-and-drop canvas.
Agentflow- Flowise's most powerful visual builder — a superset of both Chatflow and Assistant — that supports multi-agent systems, branching logic, loops, and human-in-the-loop checkpoints.
Assistant- The most beginner-friendly Flowise builder, which lets you create an AI agent that follows instructions, uses tools, and retrieves answers from uploaded files — without wiring individual nodes.
Node- A single building block on the Flowise canvas — each node performs one job (e.g. call an LLM, search a document, run a tool) and connects to other nodes via edges.
Canvas- The visual workspace inside Flowise where you drag, drop, and wire together nodes to design an AI workflow.
LLM- Large Language Model — the AI text engine (such as GPT-4 or Claude) that reads instructions and generates responses inside a Flowise workflow.
Agent- An autonomous AI component that can reason, plan, decide which tools to use, and take actions — unlike a plain LLM node, it makes decisions dynamically.
Tool- A function that an agent can call to interact with the outside world, such as searching the web, running a calculation, or making an HTTP request.
RAG- Retrieval-Augmented Generation — a technique where the AI fetches relevant passages from your own documents before answering, so responses are grounded in your data rather than general training.
Document Store- A Flowise feature that lets you upload, split, and index your own files so that agents can search and retrieve information from them.
Vector Store- A specialised database that stores text as lists of numbers (vectors) so that semantically similar content can be found quickly, even if the exact words differ.
Embedding- A numerical representation of a piece of text — two embeddings that are close together in number-space mean the texts have similar meaning, enabling similarity search.
Chunk- A small segment of a document created by splitting the original file into pieces before indexing, so that only the most relevant part is retrieved rather than the whole document.
Upsert- The action in Flowise that sends your prepared document chunks into a Vector Store — it adds new entries and updates existing ones without creating duplicates.
Flow State- A runtime key-value store that passes data between nodes within a single Agentflow run, letting distant nodes read values set by earlier nodes.
Human Input node- An Agentflow node that pauses execution and waits for a real person to review, approve, or provide information before the workflow continues.
Memory- A component that stores previous conversation messages so the AI can refer back to earlier exchanges within the same chat session.
Buffer Window Memory- A memory type that keeps only the most recent K conversation turns, discarding older ones, to avoid sending too much history to the LLM.
Streaming- A mode where the AI sends its reply token-by-token in real time as it is generated, rather than waiting until the full response is complete before showing anything.
MCP- Model Context Protocol — an industry-standard interface that lets AI agents connect to external tools and data sources through a common, provider-maintained interface.
Retriever- A node that queries a Document Store using semantic similarity to fetch the passages most relevant to the user's question.
Execute Flow node- An Agentflow node that calls another Chatflow or Agentflow as a sub-workflow, letting you reuse or nest existing flows inside a larger one.
7See also
💬 Discuss this chapter
Ask, share, or report — over on the Heidelberg AI community forum.