DEV Community

Cover image for O que é Flowise? O construtor low-code de código aberto para apps LLM e agentes de IA
Lucas
Lucas

Posted on • Originally published at apidog.com

O que é Flowise? O construtor low-code de código aberto para apps LLM e agentes de IA

Se você quer criar um aplicativo LLM ou um agente de IA sem conectar cada componente manualmente em Python, o Flowise oferece uma alternativa visual e low-code. Você monta nós, conecta entradas e saídas, testa o fluxo na própria interface e publica um endpoint REST para consumir no seu app. Neste guia, você verá o que é o Flowise, quando usar chatflows, agentflows ou assistentes, como executar localmente, como chamar o endpoint de previsão e como testar esse contrato de API. Se você já leu nossa explicação sobre LangGraph, pense no Flowise como o lado visual-first do espectro. O código-fonte está no README do projeto no GitHub.

Experimente o Apidog hoje

O que é o Flowise

Flowise é uma plataforma open source para construir agentes de IA e fluxos de trabalho com LLMs. Ele é distribuído sob a licença Apache 2.0, então você pode executá-lo localmente, hospedá-lo por conta própria ou fazer um fork.

Flowise

A ideia central é uma tela baseada em nós. Cada nó representa um bloco de construção:

  • modelo de chat;
  • armazenamento de vetores;
  • carregador de documentos;
  • memória;
  • retriever;
  • ferramenta externa;
  • lógica personalizada.

Você arrasta os nós para a tela, conecta as saídas às entradas e define como os dados fluem. Quando o fluxo está pronto, o Flowise o expõe como uma API REST que pode ser chamada por qualquer frontend, backend ou serviço interno.

Nos bastidores, o Flowise conecta componentes de frameworks como LangChain e LlamaIndex. Se você já trabalhou com cadeias, agentes, retrievers, vector stores ou query engines, os conceitos serão familiares. A diferença é a forma de montagem: em vez de importar classes e escrever a orquestração em código, você compõe o fluxo visualmente.

A troca é clara:

  • você ganha velocidade, legibilidade e colaboração visual;
  • você perde parte do controle granular de uma implementação code-first.

Chatflows, agentflows e assistentes

Flowise oferece três tipos principais de construtores. Escolher o tipo certo evita complexidade desnecessária.

Tipo de construtor Melhor para Escopo
Assistente Iniciantes; assistentes de chat que seguem instruções, usam ferramentas e fazem RAG sobre arquivos enviados Mais restrito, mais guiado
Chatflow Sistemas de agente único, chatbots, fluxos LLM mais simples; suporta Graph RAG e rerankers Agente único
Agentflow Sistemas multiagente e orquestração complexa com ramificação, looping e roteamento Mais amplo; um superconjunto de Chatflow e Assistente

Quando usar um chatflow

Use um chatflow quando você precisa de um pipeline direto:

  1. receber uma pergunta;
  2. recuperar contexto;
  3. chamar um modelo;
  4. retornar uma resposta.

Esse formato funciona bem para:

  • chatbots de suporte;
  • assistentes internos;
  • RAG sobre documentação;
  • fluxos LLM com um único agente.

Quando usar um agentflow

Use um agentflow quando o fluxo precisa coordenar múltiplos passos ou agentes.

Exemplos:

  • um agente classifica a intenção e outro executa a tarefa;
  • o fluxo roteia perguntas para diferentes ferramentas;
  • há ramificações condicionais;
  • o workflow precisa repetir etapas até alcançar um critério;
  • múltiplos agentes passam trabalho uns para os outros.

O agentflow é a camada indicada para orquestração mais complexa.

Quando usar um assistente

Use um assistente quando você quer sair do zero rapidamente.

Você define instruções, adiciona ferramentas e aponta arquivos para recuperação. É a opção mais guiada e com menos decisões de arquitetura.

Como montar um fluxo no Flowise

A construção no Flowise segue um padrão simples.

  1. Crie um novo chatflow.
  2. Arraste um nó de modelo de chat para a tela.
  3. Escolha um provedor, como OpenAI, Anthropic ou um modelo local.
  4. Se precisar de RAG, adicione um carregador de documentos.
  5. Adicione um armazenamento de vetores.
  6. Conecte o carregador ao vector store.
  7. Adicione um retriever para buscar contexto.
  8. Conecte o contexto ao modelo.
  9. Se precisar manter histórico, adicione um nó de memória.
  10. Salve o fluxo.
  11. Abra o painel de chat e teste uma pergunta real.

Um fluxo RAG básico pode seguir esta estrutura:

Pergunta do usuário
        |
        v
Retriever -> Contexto recuperado
        |
        v
Modelo de chat
        |
        v
Resposta
Enter fullscreen mode Exit fullscreen mode

O editor visual também suporta:

  • expressões;
  • nós de código personalizados;
  • ramificação;
  • looping;
  • roteamento;
  • lógica condicional.

Quando um nó pronto não cobre seu caso, você pode criar uma função personalizada e manter o restante do fluxo visual.

Implantando o Flowise

O Flowise roda como uma aplicação Node.js e usa a porta 3000 por padrão.

Rodando com npm

Para testar localmente:

npm install -g flowise
npx flowise start
Enter fullscreen mode Exit fullscreen mode

Depois, abra:

http://localhost:3000
Enter fullscreen mode Exit fullscreen mode

Rodando com Docker

Para uma execução mais repetível:

docker run -d --name flowise -p 3000:3000 flowiseai/flowise
Enter fullscreen mode Exit fullscreen mode

Verifique se o container está rodando:

docker ps
Enter fullscreen mode Exit fullscreen mode

Acesse:

http://localhost:3000
Enter fullscreen mode Exit fullscreen mode

O Flowise também suporta implantações auto-hospedadas e air-gapped, úteis quando seus dados não podem sair da sua rede.

Chamando o endpoint de previsão REST

Depois que um fluxo é salvo, o Flowise expõe uma API REST para ele. A documentação oficial de previsão cobre o formato completo da requisição.

Cada chatflow ou agentflow recebe um endpoint neste formato:

POST /api/v1/prediction/{id}
Enter fullscreen mode Exit fullscreen mode

O {id} é o ID do fluxo.

Uma chamada mínima com curl:

curl -X POST http://localhost:3000/api/v1/prediction/<flow-id> \
  -H "Content-Type: application/json" \
  -d '{"question": "Qual é o horário de funcionamento da sua loja?"}'
Enter fullscreen mode Exit fullscreen mode

O campo principal é question, mas o corpo pode incluir outros parâmetros, dependendo do fluxo.

Exemplo com configurações adicionais:

curl -X POST http://localhost:3000/api/v1/prediction/<flow-id> \
  -H "Content-Type: application/json" \
  -d '{
    "question": "Resuma a política de reembolso.",
    "overrideConfig": {
      "temperature": 0.2
    },
    "history": [
      {
        "role": "user",
        "content": "Você pode me ajudar com dúvidas da loja?"
      },
      {
        "role": "assistant",
        "content": "Sim, posso ajudar."
      }
    ]
  }'
Enter fullscreen mode Exit fullscreen mode

O corpo da requisição pode suportar:

  • question: pergunta enviada ao fluxo;
  • streaming: habilita transmissão de tokens;
  • overrideConfig: sobrescreve configurações por requisição;
  • history: envia histórico anterior;
  • uploads: envia imagens ou áudio, quando suportado pelo fluxo.

Quando o streaming está ativado, o Flowise emite eventos como:

  • start;
  • token;
  • metadata;
  • end.

Esse endpoint é o contrato entre o Flowise e o restante da sua aplicação. Por isso, ele deve ser tratado como qualquer outra API crítica: versionado, testado e monitorado.

Quando usar low-code e quando preferir code-first

Flowise é uma boa escolha quando você precisa de:

  • prototipagem rápida;
  • fluxos visuais legíveis pela equipe;
  • chatbots internos;
  • assistentes RAG;
  • demos funcionais;
  • colaboração com pessoas não engenheiras.

A tela visual ajuda a explicar o comportamento do agente sem exigir que todos leiam arquivos Python.

Frameworks code-first se destacam quando você precisa de mais controle. Se você está versionando lógica de agente no Git, escrevendo testes unitários detalhados para cada etapa ou criando máquinas de estado específicas, uma biblioteca como LangGraph ou o Google Agent Development Kit pode ser mais adequada.

O mesmo vale para o OpenAI Agents SDK quando seus agentes dependem de chamadas de ferramentas personalizadas.

Na prática, muitas equipes usam os dois caminhos:

  1. prototipam no Flowise;
  2. validam o comportamento com usuários;
  3. estabilizam o design;
  4. portam partes críticas para código, se necessário.

A decisão não precisa ser binária. O Flowise também oferece API, CLI, SDKs, tracing, avaliação e human-in-the-loop. Ele pode ir além de um protótipo simples. Mas quanto mais sua lógica se parece com software tradicional, mais uma stack code-first tende a recompensar.

Testando o endpoint de previsão e as APIs do fluxo

Um agente no Flowise é tão confiável quanto as APIs por trás dele.

Normalmente, o fluxo chama:

  • uma API de LLM;
  • um banco ou vector store;
  • ferramentas externas;
  • APIs REST internas;
  • serviços de terceiros.

Esses pontos podem falhar em produção. Por isso, teste tanto o endpoint do Flowise quanto as APIs que ele usa.

1. Teste o endpoint de previsão

Trate este endpoint como qualquer endpoint REST:

POST /api/v1/prediction/{id}
Enter fullscreen mode Exit fullscreen mode

No Apidog, crie uma requisição com:

{
  "question": "Qual é o horário de funcionamento da sua loja?"
}
Enter fullscreen mode Exit fullscreen mode

Depois, adicione asserções de API para validar o contrato da resposta.

Exemplos do que verificar:

  • status HTTP esperado;
  • presença do campo de resposta;
  • tipo dos campos retornados;
  • ausência de erro;
  • tempo máximo de resposta;
  • conteúdo mínimo esperado.

Exemplo de checklist:

Status é 200
Resposta contém texto
Resposta não contém campo de erro
Tempo de resposta está dentro do limite esperado
Enter fullscreen mode Exit fullscreen mode

Isso ajuda a detectar mudanças no fluxo que quebram o contrato antes que seu app seja afetado.

2. Teste as APIs que o fluxo chama

Além do endpoint de previsão, teste diretamente cada dependência externa.

Por exemplo:

  • endpoint do provedor LLM;
  • API de busca;
  • API de CRM;
  • API de pedidos;
  • API de autenticação;
  • ferramenta interna chamada pelo agente.

Se você quer desenvolver sem gastar tokens ou bater em rate limits, use uma API mock com respostas realistas e previsíveis.

Esse padrão é útil para:

  • simular respostas do LLM;
  • simular ferramentas de terceiros instáveis;
  • testar erros controlados;
  • manter testes determinísticos;
  • rodar testes em CI sem depender de serviços externos.

Exemplo de resposta mockada para uma ferramenta de pedidos:

{
  "orderId": "12345",
  "status": "shipped",
  "estimatedDelivery": "2026-07-12"
}
Enter fullscreen mode Exit fullscreen mode

Depois, valide se o fluxo interpreta esse formato corretamente.

Há um guia mais completo em nosso guia de harness de teste de agente de IA.

3. Separe ambientes

Também vale configurar ambientes diferentes para desenvolvimento, teste e produção.

No Apidog, você pode armazenar variáveis como:

base_url
flow_id
llm_api_key
tool_api_key
Enter fullscreen mode Exit fullscreen mode

Assim, o mesmo teste pode rodar contra ambientes diferentes sem alterar a requisição.

Para baixar o Apidog e configurá-lo, o processo leva poucos minutos.

Perguntas frequentes

O Flowise é gratuito e de código aberto?

Sim. O Flowise é open source sob a licença Apache 2.0. Você pode executá-lo gratuitamente em uma implantação própria usando npm ou Docker. Também existe uma opção de nuvem hospedada se você preferir não gerenciar infraestrutura.

Para ambientes privados ou air-gapped, a rota auto-hospedada mantém tudo dentro da sua rede.

O Flowise usa LangChain?

O Flowise conecta componentes de LangChain e LlamaIndex. Os nós na tela mapeiam para conceitos familiares desses frameworks, como cadeias, agentes, armazenamentos de vetores, retrievers e motores de consulta.

Você usa esses blocos sem escrever manualmente todo o código de conexão.

Qual é a diferença entre um chatflow e um agentflow?

Um chatflow é indicado para sistemas de agente único, chatbots e pipelines LLM mais simples.

Um agentflow é mais amplo. Ele lida com sistemas multiagente e orquestrações com ramificação, looping e roteamento.

Comece com um chatflow para um assistente direto. Use um agentflow quando múltiplos agentes ou etapas precisarem coordenar trabalho.

Como eu testo a API de um fluxo do Flowise?

Chame o endpoint:

POST /api/v1/prediction/{id}
Enter fullscreen mode Exit fullscreen mode

Envie um corpo JSON com uma question:

{
  "question": "Como acompanho meu pedido?"
}
Enter fullscreen mode Exit fullscreen mode

Você pode fazer isso com curl, SDKs oficiais ou uma ferramenta dedicada.

No Apidog, você envia a requisição, valida a resposta, simula as APIs LLM e de ferramentas que o fluxo chama e executa os testes em CI.

Para detalhes sobre autenticação e streaming em endpoints LLM, veja nosso guia sobre como testar a API do ChatGPT com o Apidog.

Conclusão

Flowise é uma forma low-code de construir aplicativos LLM e agentes de IA. Você monta fluxos em uma tela de nós, escolhe entre chatflows, agentflows e assistentes, e publica um endpoint REST sem escrever toda a orquestração manualmente.

Ele funciona muito bem para protótipos, chatbots internos, assistentes RAG e fluxos que precisam ser entendidos pela equipe. Frameworks code-first ainda são melhores quando você precisa de controle profundo, testes unitários detalhados e lógica altamente customizada.

Independentemente da abordagem, o agente depende das APIs que chama. Teste o endpoint de previsão, simule LLMs e ferramentas externas, valide o contrato das respostas e execute esses testes de forma automatizada. Isso aumenta a chance de o agente se comportar em produção da mesma forma que se comportou na tela do Flowise.

Top comments (0)