Nodes

Nodes are the building blocks of MindedJS flows - discrete processing units that handle different aspects of your agent's workflow.

Node Types Overview

Node Type	Purpose	Description
Trigger	Entry Points	Start flows from various sources
Prompt	LLM Processing	Generate responses using language models
Tool	Actions	Execute external functions and APIs
Junction	Flow Control	Route and organize flow logic
Jump To	Flow Control	Jump to specific nodes or subflows

Trigger Nodes

Trigger nodes are entry points that start your flows and initialize them with memory and messages.

Trigger Types

App Trigger

- type: trigger
  triggerType: app
  name: zendesk-ticket-created
  displayName: Zendesk Ticket Created
  appTriggerId: zendesk-new-ticket

Webhook Trigger

- type: trigger
  triggerType: webhook
  name: payment-failed-notification
  displayName: Payment Failed Notification

Trigger Implementation

Handle triggers in your agent code:

import { events } from 'mindedjs/src/index';
import { HumanMessage } from '@langchain/core/messages';

agent.on(events.TRIGGER_EVENT, async ({ triggerName, triggerBody }) => {
  if (triggerName === 'customer-support-request') {
    return {
      memory: { customerQuery: triggerBody, timestamp: new Date().toISOString() },
      messages: [new HumanMessage(triggerBody)],
    };
  }
  // Return { isQualified: false } to prevent flow execution
});

Prompt Nodes

Prompt nodes process input through LLM to generate intelligent responses or invoke tools. Prompt nodes are commonly used to notify and collect information.

Use Cases

• Notify the user about the result of a previous node.

• Collect information from the user.

• Invoke (scoped) tools.

Handle AI message

• Prompt nodes usually result in an AI message being sent to the user. Use the agent.on(AgentEvents.AI_MESSAGE, callback) event handle to route the message according to user requirement (e.g. send email, slack message, update Jira ticket etc).

• In development mode (playground), the message is automatically shown in the chat regardless of the message handler.

Context

• Prompt nodes automatically have access to previous nodes' output as context.

• You can also inject context from the memory object using the {memory.propertyName} placeholder.

Properties

• humanInTheLoop?: boolean - When true, pauses execution after this node for human input before continuing. Use this property only if you need to gather an input from the user. Usually combined with a promptCondition edge to allow for iterative processing over human input.

• canStayOnNode?: boolean - When true, allows the node to route back to itself for iterative processing. Usually combined with humanInTheLoop: true to allow for iteration over human input.

• prompt: string - The prompt to be sent to the LLM. The prompt is an instruction for what AI message to generate or a (scoped) tool to invoke. This is not general instruction for what the agent should do (e.g. "wait for x").

• sendAiMessage?: boolean - When false, the AI response is processed internally without sending to the user. Default: true. Set to 'false' for internal calculations, reasoning, or decision-making logic that shouldn't be visible to users.

Limitations

• Prompt nodes can not save information to memory directly. Rather the user & agent messages are stored in the messages array of the state object. Making user's input available to the next prompt nodes or tools in the form of input schema.

• Image recognition is only supported when a user attaches an image to the message. If you need to extract information from an image, use a tool with agent.llm to process the image. Return the result in the tool response so following prompt nodes can use it.

• By default, prompt nodes send a message to the user. Set sendAiMessage: false if you want internal processing without user-facing output.

Prompt examples

• "Draft a professional email to the merchant requesting verification of the dispute"

• "Ask the user for their contact information (name, email, phone)"

Common Prompt Patterns

Extract Information from User

Use humanInTheLoop: true and canStayOnNode: true with promptCondition edges for iterative information gathering:

- type: promptNode
  name: collect-customer-info
  displayName: Collect Customer Information
  prompt: 'Ask the user for their contact information (name, email, phone).'
  humanInTheLoop: true
  canStayOnNode: true

edges:
  - source: collect-customer-info
    target: validate-info
    type: promptCondition
    prompt: 'Has all required information been collected?'

Notify User

Use standard prompt nodes with stepForward edges for one-way notifications:

- type: promptNode
  name: send-confirmation
  displayName: Send Confirmation
  prompt: 'Send confirmation: Order {memory.orderId}, Total: {memory.orderTotal}'

edges:
  - source: process-order
    target: send-confirmation
    type: stepForward

Custom LLM Configuration

Provide a custom LLM configuration to the prompt node using the llmConfig property.

llmConfig:
  name: ChatOpenAI  # or ChatAnthropic
  properties:
    model: gpt-4o
    temperature: 0
    max_tokens: 500

Internal Processing (No User Message)

To process logic internally without sending a message to the user, set sendAiMessage: false:

- type: promptNode
  name: calculate-refund-amount
  displayName: Calculate Refund Amount
  prompt: 'Based on the order details: {memory.orderItems}, calculate the appropriate refund amount.'
  sendAiMessage: false

Use cases for sendAiMessage: false:

• Internal calculations and reasoning: Determining refund amounts, calculating discounts, analyzing data

• Decision-making logic: Evaluating conditions before taking actions

• Information extraction: Processing and structuring data for subsequent nodes

• Pre-processing: Preparing inputs for tools or other nodes

The AI response is added to conversation history and available to subsequent nodes, but not sent to the user.

Tool Nodes

Tool nodes execute functions to perform actions like API calls or database queries.

Basic Tool Node

- type: tool
  name: lookup-customer-order
  displayName: Lookup Customer Order
  toolName: lookupOrder

Junction Nodes

Junction nodes provide flow control without processing, useful for organizing routing logic.

Basic Junction

- type: junction
  name: customer-routing-hub
  displayName: Customer Routing Hub

Routing Example

- type: junction
  name: route-customer-request
  displayName: Route Customer Request

edges:
  - source: route-customer-request
    target: vip-support
    type: logicalCondition
    condition: "state.memory.customerTier === 'premium'"
  - source: route-customer-request
    target: standard-support
    type: logicalCondition
    condition: "state.memory.customerTier === 'standard'"

Jump To Nodes

Jump To nodes provide direct navigation to specific nodes, enabling flow transitions and subflow execution.

Basic Jump To Node

- type: jumpToNode
  name: go-to-order-processing
  displayName: Go To Order Processing
  targetNodeId: process-customer-order

Cross-Flow Navigation

Jump To nodes enable navigation between flows. Target nodes can exist in different flow files, and state is preserved during jumps:

# flows/mainFlow.yaml
- type: jumpToNode
  name: go-to-refund-flow
  displayName: Go To Refund Flow
  targetNodeId: refund-processor

Best Practices

• Use descriptive names: technical-support-specialist not agent-1

• Keep prompts focused: Define specific roles and context, avoid overly broad prompts

• Always include displayName: Required for prompt nodes, recommended for all nodes

Browser Task Nodes

Browser task nodes allow your agent to interact with web pages using AI-powered automation.

Basic Browser Task

- type: browserTask
  name: search-products
  displayName: Search Products
  prompt: 'Go to amazon.com and search for wireless headphones under $100'

Custom Model

Specify which AI model to use (default: gpt-4o):

- type: browserTask
  name: complex-task
  displayName: Complex Web Task
  prompt: 'Navigate to the support page and fill out the contact form'
  model: 'gpt-4o' # Options: gpt-4o, gpt-4-turbo, claude-3-opus, etc.

Next Steps

• Edges - Connect nodes with intelligent routing

• Tools - Build powerful tool functions

• Memory Types - Design effective state management

Nodes are your building blocks - combine them strategically to create powerful AI workflows! 🔧