Summary of "Flowise AI Sequential Agents Masterclass 2025: Beginner to Pro"

Flowise AI Sequential Agents Masterclass (Beginner → Pro)

What this video covers (high level)

• Full beginner → advanced walkthrough to build sequential (agentic) workflows in Flowise:
  • Installing Flowise locally and deploying on a remote host (Railway).
  • Explanation of sequential-agents architecture vs multi‑agents.
  • Node-by-node walkthrough of all sequential-agent nodes and when/how to use them.
  • Live build: an order-status tracking bot using all sequential nodes.
  • Langsmith tracing for debugging and prompt inspection.
  • Exposing flows via Flowise APIs and overriding node/session/global values.
  • Best practices for designing workflows and a short demo/pitch of Flowboard 360 (self-hosted chatbot metrics/dashboard).

---

Installation & deployment (quick guide)

Local

• Clone the Flowise GitHub repo.
• Install Node.js + npm and pnpm: npm i -g pnpm.
• Commands: pnpm install → pnpm build → pnpm start.
• Configure .env from packages/server/.env.example with DB credentials (Postgres/MySQL) and initial auth username/password.
• App runs on http://localhost:3000.

Remote (Railway)

• Use prebuilt Railway templates: Flowise + MySQL or Flowise + Postgres.
• Fill username/password on deploy; Railway provides a public URL and supports custom domains via DNS.

---

Sequential agents: architecture and when to use

• Two Flowise architectures:
  • Multi-agents: supervisor + worker — easier setup but less granular control.
  • Sequential agents: explicit node graph (start → agents/LLMs/tools/conditions/loops → end) — fine-grained control for complex workflows.
• Sequential pattern: chain nodes to accomplish a goal; branch with condition nodes; loop/backtrack with loop nodes.

---

Node reference (purpose, inputs, notes)

• Start node Mandatory. Accepts chat model, agent memory, initial state, input moderation. Begins the flow and can initialize variables.

• State node Defines session/state variables (visual table or JS). Operations: replace or append.

• Agent node Reasoning/decision node. Accepts tools, chat model, can require human approval (human-in-the-loop). Can update state (table or code). Set max iterations to prevent recursion.

• LLM node Simpler LM call (no tools). Supports structured JSON outputs via a schema when predictable output is needed.

• Condition agent Uses an LM to decide route (has a “brain”). Runs prompts and returns branches (visual table or code).

• Condition node Pure conditional branching (no LM call). Evaluates expressions/values.

• Custom JS function Utility node for data transformation or state updates. Can return AI/human messages or update state. Useful to manipulate data between nodes.

• Loop node Loops back to an agent/LLM by name/ID (used for retries / repeated attempts).

• Tool node Intermediary to call external tools/APIs. LLM nodes don’t accept tools directly; use Tool nodes for API calls or multiple tools.

• Execute flow Calls another Flowise workflow (bridge workflows). Pass inputs and return AI/human/state between flows.

• End node Marks completion (one input, no output).

---

Langsmith (tracing & debugging)

• Integrate Langsmith by generating an API key and adding it as a provider in Flowise config.
• Langsmith captures traces showing node-level prompts, LM calls, and metadata — invaluable for debugging prompt issues (the most common failure mode).
• Use traces to validate prompt text and overridden parameters.

Tip: Always inspect Langsmith traces while developing — seeing the actual prompt and model metadata often reveals the root cause of issues.

---

Live demo: Order status tracking bot (core flows & techniques)

• Objective: Accept an order ID → fetch order details (custom tool calling API) → return a concise order status to the user.
• Components used:
  • Start node with a chat model (e.g., OpenAI).
  • Agent node “check order status” with a system prompt that instructs steps and tool use.
  • Custom Tool: input schema { orderId: string }, JavaScript template for HTTP GET to the order API endpoint; inject input via ${orderId}.
  • Test using the embedded widget (copy HTML snippet and open locally).
• Prompt iteration: refine the system prompt so the agent returns only the desired status (prompt engineering).

---

Handling edge cases demonstrated

1. Irrelevant user input

   • Use a Condition Agent (“router agent”) after Start to classify two routes:
     • If LM returns keyword “order status” → route to order check agent.
     • Else → route to a separate LLM flow (“friendly conversation”) to guide the user back to order check.
   • Router should output just the route keyword (e.g., “order status” or “conversation”).
   • The “friendly conversation” can be a separate flow invoked via Execute Flow.

2. Memory

   • Add agent memory (e.g., Postgres Agent Memory) to remember user information (like name) across the session.

3. Network / API reliability (retries)

   • Make tools return a consistent error sentinel (e.g., "error") on non-200 or exceptions.
   • Use a Condition node to check for the sentinel; if error → Loop node back to agent to retry.
   • Prevent infinite loops using:
     • A state variable max_retry_count (initial value, e.g., 2).
     • A Custom JS function node to decrement max_retry_count only when tool response == "error".
     • A Condition node order == "error" && max_retry_count > 0 to decide whether to loop or end.
   • This implements controlled retries and graceful exit.

---

Bridging flows: Execute Flow node

• Extract modular pieces (e.g., “friendly conversation”) into separate workflows.
• Use Execute Flow to call those workflows by id/key; the executed flow can return AI messages and updated state to the main flow.
• Useful for modularization and reuse.

---

APIs, embedding and overrides

• Flowise exposes an API endpoint for invoking flows; dashboard provides JavaScript and Python examples.
• Include the Flowise authorization key in request headers.
• Override behavior via a JSON override_config:
  • Override node parameters (e.g., temperature): enable “allow override” for that node, then target by node ID.
  • Override session/state variables: provide a state_memory list in override_config to replace session variables (operation: replace, value).
  • Override global variables: set global variable values (used with double-curly / $v access in prompts); enable override in the dashboard.
• Use Langsmith traces to confirm metadata and override effects (e.g., changed temperature).

---

Best practices & workflow design tips

• Use Langsmith tracing while building — inspect the actual prompts sent to the model.
• Map the entire flow on paper or a whiteboard first, including branches and edge cases.
• Break complex flows into modular subflows and reuse via Execute Flow.
• Use state variables to pass data between nodes, and Custom JS nodes for transformations or deterministic logic that shouldn’t rely on language models.

---

Product plug: Flowboard 360

• Flowboard 360 is a self-hosted dashboard to monitor chatbot conversations, metrics, leads, feedback, and export/share conversation data with clients (custom branding, client accounts).
• Integrates with Flowise flows to collect conversations; useful for agency/client reporting.
• The author demoed Flowboard 360 and referenced videos, docs, and an early-adopter offer in the video description.

---

Files, resources & utilities mentioned

• Flowise GitHub repo (for local install).
• Railway templates for instant deploy (Flowise + MySQL/Postgres).
• Langsmith (for tracing).
• Flowboard 360 (self-hosted analytics dashboard).
• Example embed HTML snippet for local chat widget testing.
• API examples (JavaScript/Python) and override_config examples in the dashboard.

---

Practical checklist (short)

• Clone & configure .env (DB credentials + auth).
• pnpm install → pnpm build → pnpm start.
• Add Langsmith tracing early.
• Design the flow on paper: main path + edge cases.
• Build nodes incrementally: Start → Agent/LLM → Tool → Condition → Loop → End.
• Use Tool nodes for API calls (with input schema + JS).
• Add memory when conversation context needs persistence.
• Implement retry logic with Loop + sentinel + counter + Custom JS.
• Modularize with Execute Flow.
• Enable node override if you plan to change node params via external API.
• Use override_config to pass session/global values when invoking flows via API.

---

Downloads & assets

• The author notes that flows, Railway templates, and Flowboard360 links are included in the original video description (downloadable demo flow and templates).

---

Main speakers / sources

• Instructor: Manoj (references to his agency Falcon27 — falcon27.com).
• Tools & platforms referenced: Flowise, Langsmith, Railway, Flowboard 360.

Category

Technology

---

Share this summary

Share on X/Twitter Share on Facebook Share on LinkedIn Share on Reddit Share on WhatsApp Share on Telegram

---

Is the summary off?

If you think the summary is inaccurate, you can reprocess it with the latest model.

Reprocess summary

Video