Flowise: Your Own AI Chatbot, Without a Line of Code
Practice

Flowise: Your Own AI Chatbot, Without a Line of Code

With Flowise you click together a chatbot that knows your own documents — Qdrant as its memory, a model in front, no programming required.

Too much jargon?→ Look it up in the glossary

Recently we started Qdrant — a vector store that searches by meaning. All well and good, but so far it's an empty shelf. Today we put a chatbot in front of it that actually uses that shelf. And the best part: without a single line of code.

The tool for that is called Flowise. Open source, runs on your own machine, and you build complete AI workflows with it by connecting boxes — like a flowchart, except this one actually works at the end.

What Flowise is

Picture a whiteboard where you drag building blocks around: one loads documents, one splits them, one talks to Qdrant, one is the chat model. You draw connecting lines between them — and there's your AI application. That's exactly what Flowise is: a visual builder for language-model workflows.

It's open source (Apache 2.0 licence), runs in Docker on your own machine, and costs nothing itself. At most you pay for the model behind it — and even that only if you pick a paid one instead of a local one.

All at once: a docker-compose

You don't want to start Flowise, Qdrant, and a local model by hand one at a time. A small docker-compose.yml brings all three together:

services:
  flowise:
    image: flowiseai/flowise
    container_name: flowise
    restart: unless-stopped
    ports:
      - "3000:3000"
    volumes:
      - ./flowise:/root/.flowise
  qdrant:
    image: qdrant/qdrant
    container_name: qdrant
    restart: unless-stopped
    ports:
      - "6333:6333"
    volumes:
      - ./qdrant:/qdrant/storage
  ollama:
    image: ollama/ollama
    container_name: ollama
    restart: unless-stopped
    ports:
      - "11434:11434"
    volumes:
      - ./ollama:/root/.ollama

docker compose up -d — three services, one command. You reach Flowise at http://localhost:3000, the rest waits in the background. Important: inside Compose the services address each other by name — in Flowise you enter the Qdrant address as http://qdrant:6333 and Ollama as http://ollama:11434, not localhost.

This is deliberately the bare-minimum example: container_name and a restart rule are in there, but environment variables for logins, health checks, and further settings get added as needed — in production it gets a bit fiddlier. But hey: the final docker-compose.yml can be put together for you by Claude Code, ChatGPT, or Mistral too — just ask them.

By the way: if you run the chat and embedding models via a paid provider anyway, you can drop the ollama part from the compose. Honestly, on ordinary hardware Ollama is often too slow for chatting — and with a chatbot nobody waits two minutes for an answer. For free experimenting it's still ideal: play locally first, switch to a fast API later.

Your first chatbot — three nodes are enough

Sounds like a lot of tinkering. It isn't. For a bot that knows your documents you need, at the core, exactly three building blocks:

  1. Qdrant — the vector store from last time, with an embedding block attached that turns the texts into numbers.
  2. Chat model — phrases the answer (locally via Ollama or via API).
  3. Conversational Retrieval QA Chain — the centrepiece: it takes the question, has Qdrant find the matching passages, and hands them to the model.

Three boxes, a few lines, done. What was a Python script in the Qdrant post is a picture you click together here.

And if you don't want to start from scratch: Flowise ships a marketplace of ready-made templates — including a "Documents Q&A (RAG)" that has exactly this skeleton already clicked together. Load it, drop in your own blocks, go.

In use it runs in two phases: first you fill Qdrant once with your documents (the "indexing"), after that the bot answers questions — it finds the relevant spots and answers based on them instead of off the cuff. That's RAG, made clickable.

Give the bot a role: the system prompt

One thing is still missing for a usable bot: the system prompt. It's the instruction the bot keeps in mind on every question — who it is, what it answers, and above all what it doesn't. In Flowise you enter it directly on the chain or model node. A small example:

You are the support assistant for my club handbook. Answer questions only based on the provided documents. If the answer isn't in them, honestly say "I don't know" — don't make anything up. No legal or medical advice. Answer briefly, kindly, and in English.

That "don't make anything up" is worth its weight in gold: it keeps the bot on the facts from your documents and curbs hallucination.

And which documents do you feed it? For a club bot like this, say: the club statutes, the house rules, the corporate design (logo rules, colours, fonts), the — publicly available anyway — meeting minutes, and the org chart. Once embedded in Qdrant, the bot answers questions like "Who's on the board?" or "How do I cancel my membership?" with the prompt above — from your documents, not from the web.

If you put it out in public, the system prompt is also where you write down what it should not talk about.

What you need for it

Three ingredients you already know from the last posts:

  • Qdrant — as the memory. Already running.
  • An embedding model — locally via Ollama (nomic-embed-text and friends) or via API. Important: the same model for indexing and for asking, otherwise the numbers don't match up.
  • A chat model — the one that phrases the answer. Flowise talks to over a hundred models: locally via Ollama, or Claude, GPT, Gemini and others via API.

Run it all locally and you get a chatbot where not a single document leaves your own machine. For confidential content, the strongest argument there is.

What does it cost?

Flowise itself: nothing. Qdrant: nothing. That leaves the models. Locally via Ollama you only pay for electricity. With an API model there's a price per request — and it's smaller than you'd think.

A rough calculation for one chatbot question with a cheap model (say Claude Haiku, currently around 1 US dollar per million tokens in and 5 out): the question plus the retrieved passages are maybe 2,500 tokens in, the answer 300 tokens out — that's about half a cent per question. Embedding the documents is, as worked out in the Qdrant post, even cheaper. For 5 euros of embedding credit you embed entire bookshelves.

Cheaper still with a budget provider like MiniMax: there you currently get around 1.7 billion tokens for about 20 euros — with evenly spread load. At the ~2,500 tokens per question from above, that's roughly 680,000 questions for 20 euros. Anyone with that much traffic hitting their chatbot should be thinking about bigger solutions and talking to professionals anyway. 😉

Putting it online — and what that means

On your PC the bot runs only for you. It gets interesting when you embed the chat window Flowise ships with into a website via a JavaScript snippet — then anyone can talk to it. Except: for that, Flowise has to run on a server that stays up. Your home PC is the wrong place.

What comes with that:

  • A small VPS (virtual server). Suitable ones currently start at around 5 euros a month — enough for Flowise and Qdrant if the chat and embedding models come via API. If you also want to run a small embedding model locally via Ollama, budget more like 10 euros (more RAM). But weigh it up: 5 euros of embedding credit at an API provider buys an enormous number of tokens. Local only pays off at high volume — or when the data must not leave the server at all.
  • Passwords on everything. Qdrant and Flowise start open, with no login. On the internet that's negligent — both belong behind a password or an API key.
  • A reverse proxy in front (Nginx, for example — also runs in Docker), which handles the encryption (HTTPS) and only lets through what's actually meant to go out.

Setup effort: one to three hours depending on prior knowledge. No black magic — but no one-click either.

Is it worth it for you?

If you want to query a single PDF once: use OpenWebUI, it's quicker to set up. Flowise pays off the moment you want to build something of your own that sticks around — a support bot for your docs, an assistant for your notes, a knowledge base with a chat window on your own site.

That closes the loop: from "what is a vector store" through Qdrant as the engine to the finished chatbot that really knows your content. Launch Flowise, drag the first three boxes — and watch a few lines turn into a conversation partner.