Flowise: construir agentes de IA com arrastar e soltar no Ollama

#Por que Flowise

Flowise é um construtor visual de código aberto (licença Apache 2.0) baseado em LangChain e LangGraph. Ele disponibiliza os mesmos componentes — modelos, memória, retrievers, ferramentas — na forma de nós a serem conectados, transformando um protótipo de agente de várias centenas de linhas de Python em um grafo que se entende à primeira vista.

Em comparação com o Dify, a outra plataforma no-code apresentada no site, o Flowise se concentra mais na orquestração detalhada: enquanto o Dify oferece uma experiência de produto bem estruturada (aplicativos, conjuntos de prompts, gestão de equipe), o Flowise expõe os mecanismos internos do LangChain e é mais adequado quando você quer entender e ajustar cada etapa de um agente. Ambos se conectam ao Ollama da mesma forma.

100 % local

Com Ollama, nenhum token nem documento é enviado para uma API na nuvem. Ideal para dados sensíveis ou uso off-line.

Iteração rápida

O chat de teste está integrado ao canvas: você modifica um nó e vê o efeito imediatamente, sem precisar reimplantar nada.

Exposição da API e widget

Cada chatflow se torna automaticamente um endpoint REST e um widget web que pode ser incorporado, sem precisar escrever um backend.

Extensível

Marketplace de templates, nós personalizados em JavaScript e integração de ferramentas (busca na web, calculadora, chamadas HTTP).

#Pré-requisitos

Flowise é leve: são o Ollama e o modelo carregado que consomem memória. Planeje usar uma máquina capaz de rodar confortavelmente o LLM desejado.

Ollama instalado

O daemon deve rodar e escutar em http://localhost:11434 (valor padrão). Verifique com « ollama list ».

Um modelo de chat

Um modelo capaz de chamadas de ferramentas para agentes: Qwen 3.5 8B, Granite 4.2 8B ou Mistral Small 24B de acordo com sua VRAM (7B ≈ 5 GB, 14B ≈ 9 GB, 24B ≈ 16 GB em Q4_K_M).

Um modelo de embeddings

Para o RAG: 'nomic-embed-text' ou 'mxbai-embed-large', leves e disponíveis via Ollama.

Node.js 18.15+ ou Docker

O Flowise pode ser instalado via npm ou em contêiner. O Docker é recomendado para uma implantação limpa e persistente.

#Instalar Flowise

Duas opções. A mais rápida para testes é npx; para uso contínuo com dados persistentes, prefira Docker.

# Lancement direct, sans installation permanente
npx flowise start

# Ou installation globale puis démarrage
npm install -g flowise
flowise start

docker run -d \
  --name flowise \
  -p 3000:3000 \
  --add-host=host.docker.internal:host-gateway \
  -v ~/.flowise:/root/.flowise \
  flowiseai/flowise

Abra em seguida http://localhost:3000 no seu navegador: a interface do canvas é exibida. O volume montado (~/.flowise) conserva seus chatflows e suas chaves entre dois reinícios do contêiner.

#Conectar Ollama ao Flowise

O nó “ChatOllama” é a ponte entre Flowise e o seu daemon local. O ponto-chave é a URL base: ela depende da forma como o Flowise é iniciado.

1. 01
   Adicionar o nó ChatOllama

   No canvas, abra o painel de nós, na categoria « Chat Models », e arraste « ChatOllama » para a área de trabalho.
2. 02
   Informar a URL base

   Se o Flowise estiver rodando nativamente (npx/npm), use http://localhost:11434. Se estiver rodando em Docker, use http://host.docker.internal:11434 — o contêiner não vê o “localhost” do host.
3. 03
   Escolher o modelo

   No campo « Model Name », insira o nome exato do modelo carregado no Ollama, por exemplo « qwen3.5:8b » ou « mistral-small ».
4. 04
   Ajustar as configurações

   Ajuste Temperature (0,7 para conversa, 0,1-0,3 para RAG factual) e, se necessário, o tamanho do contexto via num_ctx nas opções avançadas.

#Os nós essenciais de um chatflow

Um chatflow é lido da esquerda para a direita: os nós fornecedores (modelo, memória, ferramentas) alimentam um nó 'cadeia' ou 'agente' que gera a resposta. Aqui estão os blocos principais que aparecem em quase todos os fluxos.

Chat Model (ChatOllama)

O cérebro: o LLM que gera as respostas. Sempre presente.

Memory (Buffer Memory)

Mantém o histórico da conversa para que o agente acompanhe o raciocínio de um turno para outro.

Prompt Template

Define as instruções do sistema e a formatação da pergunta. É aqui que se dá um papel e um contexto ao modelo.

Cadeia / Agente

O nó terminal. “Conversation Chain” para um chat simples; “Tool Agent” quando o modelo precisa decidir se deve chamar ferramentas.

Tools

Capacidades externas: calculadora, pesquisa web, requisição HTTP, leitura de arquivos. Ligadas a um agente, elas ampliam o que ele sabe fazer.

Carregadores de Documentos & Armazenamento de Vetores

O componente RAG: carregam documentos, dividem-nos, indexam-nos e permitem consultas ao seu conteúdo (ver abaixo).

#Criar seu primeiro chatflow

Vamos começar pelo mais simples: um assistente conversacional com memória, ligado a Ollama. Ele servirá de base para tudo o resto.

1. 01
   Criar um novo Chatflow

   Na tela inicial, clique em “Add New” na aba Chatflows. Uma área de trabalho em branco se abre.
2. 02
   Posicionar os três nós básicos

   Arraste 'ChatOllama', 'Buffer Memory' e 'Conversation Chain' para o canvas.
3. 03
   Estabelecer as conexões

   Conecte a saída do ChatOllama à entrada « Chat Model » da Conversation Chain e a saída do Buffer Memory à entrada « Memory » da mesma cadeia.
4. 04
   Personalizar o prompt de sistema

   Na Conversation Chain, abra o campo System Message e atribua um papel: "Você é um assistente técnico conciso que responde em francês".
5. 05
   Testar no chat integrado

   Clique no ícone de chat no canto superior direito, faça uma pergunta e depois outra que dependa da primeira para verificar se a memória está funcionando.

#Um RAG completo com arrastar e soltar

O RAG (Retrieval-Augmented Generation) permite que o modelo responda com base em seus próprios documentos. No Flowise, tudo acontece no canvas: carregamos os arquivos, os vetorizamos e conectamos o retriever a uma cadeia de perguntas e respostas.

1. 01
   Carregar os documentos

   Adicione um nó «Document Loader» adequado à sua fonte: PDF File, Text File ou Folder. Ele lê o conteúdo bruto.
2. 02
   Dividir em blocos

   Conecte um « Recursive Character Text Splitter » ao carregador. Ajuste o tamanho dos blocos em torno de 1000 caracteres com 100 de sobreposição para manter o contexto entre os blocos.
3. 03
   Gerar embeddings

   Adicione um nó « Ollama Embeddings » com o modelo « nomic-embed-text » e a mesma URL de base que o ChatOllama.
4. 04
   Indexar em um armazenamento vetorial

   Arraste um “In-Memory Vector Store” (simples, para começar) ou “Chroma” para ter persistência. Conecte o splitter e os embeddings a ele.
5. 05
   Conectar um Retrieval QA Chain

   Conecte o vector store (como retriever) e o ChatOllama a um nó 'Retrieval QA Chain' ou 'Conversational Retrieval QA Chain' para manter a memória da conversa.
6. 06
   Perguntar sobre seus documentos

   Salve, abra o chat e faça uma pergunta cuja resposta está em seus arquivos. O modelo agora cita seu conteúdo.

ollama pull qwen3.5:8b
ollama pull nomic-embed-text

#Publicar e integrar o chatbot

Uma vez que o fluxo de conversa esteja satisfatório, o Flowise o disponibiliza de duas formas sem escrever uma linha de código de backend: uma API REST e um widget web para colar no seu site.

Clique na opção « API Endpoint » ou no ícone </> no canto superior direito do canvas. O Flowise gera a URL de previsão e exemplos prontos para copiar. O endpoint segue sempre o mesmo esquema, com o identificador único do fluxo de conversa.

curl http://localhost:3000/api/v1/prediction/<CHATFLOW_ID> \
  -H "Content-Type: application/json" \
  -d '{"question": "Résume la politique de retour en une phrase."}'

Para a integração web, a aba « Embed » fornece um trecho de script para ser colocado antes da tag de fechamento </body> das suas páginas. O widget exibe uma bolha de chat flutuante totalmente configurável (cores, mensagem de boas-vindas, avatar).

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

#Solução de problemas comuns

« fetch failed » no ChatOllama

URL base incorreta. No Docker, use host.docker.internal:11434, não localhost. Verifique também se o Ollama está em execução (ollama list).

O modelo nunca chama ferramentas

O LLM não oferece suporte a tool calling ou o faz de forma insatisfatória. Mude para um modelo recente treinado para isso (Qwen 3.5, Mistral Small) e verifique se você está usando um “Tool Agent”, e não uma simples cadeia.

Respostas lentas ou truncadas

Contexto grande demais para a VRAM: parte do modelo passa a ser executada na CPU. Reduza num_ctx, o tamanho dos chunks RAG ou escolha um modelo menor.

O RAG não encontra nada relevante

Chunks mal dimensionados ou modelo de embeddings incorreto. Ajuste o tamanho dos chunks, aumente o número de documentos retornados (top-k) e verifique que a indexação foi feita corretamente.

Os dados desaparecem ao reiniciar

No Docker, sem um volume montado, tudo é perdido. Certifique-se de ter « -v ~/.flowise:/root/.flowise » e use um armazenamento vetorial persistente em vez de um armazenamento em memória.

#Para se aprofundar

O Flowise é apenas uma camada visual: a qualidade dos seus agentes depende principalmente do modelo e da stack subjacente. Três guias do site dão continuidade a este guia — instalar corretamente o Ollama antes de conectar o Flowise, comparar a abordagem sem código do Dify com a do Flowise e entender os mecanismos de um RAG em Python para ajustar com precisão o que o canvas automatiza.