Search documentation

Search for pages in the documentation

AI Nodes

Process data with artificial intelligence

AI nodes bring the power of large language models into your workflows. Use them to analyze meeting transcripts, generate summaries, extract insights, classify content, and create personalized messages.

Available AI Nodes

NodeDescriptionUse Case
AI PromptGenerate text from a configured promptSummarization, extraction, classification
AI AgentAgentic AI with tool accessComplex research, multi-step analysis

Choosing Between AI Prompt and AI Agent

FeatureAI PromptAI Agent
ComplexitySimple, single-turnComplex, multi-step
Tool AccessNo toolsHas tools (search, open, list)
SpeedFasterSlower (tool loops)
CostLowerHigher
Best ForSummarization, formattingResearch, analysis

Use AI Prompt when:

  • You need straightforward text generation
  • The task is a single transformation (summarize, extract, classify)
  • You want predictable, fast execution
  • Input data is already available in the workflow

Use AI Agent when:

  • The task requires research or exploration
  • You need to search across meetings, artifacts, or contacts
  • The output depends on gathering information from multiple sources
  • You need intelligent decision-making about what to investigate

How AI Nodes Work

text
Input Data ──▶ Prompt Template ──▶ AI Model ──▶ Parsed Output
                    │                  │
                    │                  ▼
              Liquid templates    Low/Medium/High
              + context data      model tier
  1. Input arrives from upstream node
  2. Prompt is constructed using your messages + data templates
  3. AI model processes the prompt
  4. Output is parsed into the specified return type
  5. Result flows to downstream nodes

Model Tiers

AI nodes use model "tiers" rather than specific model names, allowing the system to use the best available model:

TierSpeedQualityCostUse Case
lowFastGood$Simple classification, short responses
mediumBalancedBetter$$General summarization, analysis (default)
highSlowerBest$$$Complex reasoning, nuanced analysis

Learn more about model selection →

Message Configuration

AI nodes use a messages array, similar to chat-based APIs:

text
messages: [
  { role: "system", content: "You are a helpful assistant..." },
  { role: "user", content: "Please analyze: {{ json.transcript }}" }
]

Message Roles

RolePurpose
systemSet behavior, persona, and instructions
userThe actual request/input
assistant(Optional) Example responses for few-shot learning

Using Liquid Templates

Message content supports Liquid templating:

liquid
{{ json.meeting.title }}              // Access upstream data
{{ trigger.meetingPlanId }}           // Access trigger data
{{ json.attendees | size }}           // Use filters
{% for item in json.items %}          // Loops
  - {{ item.name }}
{% endfor %}

Return Types

AI nodes parse the model output into structured data:

Scalar Types

TypeDescriptionExample Output
stringText output"Meeting was productive"
integerWhole number42
floatDecimal number0.85
booleanTrue/falsetrue

Array Types (AI Agent only)

TypeDescriptionExample Output
string_listList of strings["item1", "item2"]
integer_listList of integers[1, 2, 3]
float_listList of floats[0.5, 0.8, 0.9]
boolean_listList of booleans[true, false, true]

Execution Modes

Both AI nodes support per-item and batch modes:

Per-Item Mode

Processes each input item individually. If 5 meetings arrive, the AI runs 5 times.

Use case: Individual meeting summaries, per-attendee analysis

Batch Mode

Processes all items together. The AI sees all items at once.

Use case: Comparative analysis, aggregate summaries

Timeout and Retry

AI nodes have special timeout handling:

SettingValue
Timeout120 seconds (vs 30s for other nodes)
Retry StrategyExponential with jitter
Max Attempts2

The longer timeout accounts for:

  • Model inference time
  • Tool execution (AI Agent)
  • Complex reasoning tasks

Best Practices

1. Write Clear System Prompts

liquid
You are an expert meeting analyst. Your task is to:
1. Extract key decisions made
2. Identify action items with owners
3. Summarize the overall sentiment

Be concise and factual. Do not include information not present in the transcript.

2. Provide Structured Input

liquid
Meeting: {{ json.meeting.title }}
Date: {{ json.meeting.startTime | date: "%B %d, %Y" }}
Duration: {{ json.callRecording.duration | divided_by: 60 }} minutes

Attendees:
{% for a in json.meeting.attendees %}
- {{ a.name }} ({{ a.email }})
{% endfor %}

Transcript:
{{ json.callRecording.transcript }}

3. Specify Output Format

liquid
Respond with a JSON object containing:
- "summary": string (2-3 sentences)
- "decisions": array of strings
- "action_items": array of { "task": string, "owner": string }
- "sentiment": "positive" | "neutral" | "negative"

4. Handle Empty/Missing Data

liquid
{% if json.callRecording and json.callRecording.transcript != "" %}
  {{ json.callRecording.transcript }}
{% else %}
  No transcript available. Meeting title: {{ json.meeting.title }}
{% endif %}

5. Choose Appropriate Model Tier

TaskRecommended Tier
Binary classificationlow
Simple summarizationmedium
Meeting summarymedium
Complex analysishigh
Nuanced sentimenthigh

Common Patterns

Pattern: Summarize Then Act

text
[Load Meeting] ──▶ [AI Prompt: Summarize] ──▶ [Slack Post]

Pattern: Classify Then Route

text
                              ┌──▶ [High Priority Handler]
[AI Prompt: Classify] ──▶ [If] ├──▶ [Medium Priority Handler]
                              └──▶ [Low Priority Handler]

Pattern: Research Then Report

text
[AI Agent: Research competitors] ──▶ [AI Prompt: Format report] ──▶ [Email]

Error Handling

AI nodes can fail for several reasons:

ErrorCauseSolution
TimeoutComplex prompt, slow modelSimplify prompt, try lower tier
Parse errorOutput doesn't match expected typeImprove format instructions
Rate limitToo many requestsAdd delays, reduce frequency
Content filterOutput triggered safety filtersAdjust prompt, avoid sensitive topics

Connect error outputs to handle failures gracefully:

text
[AI Prompt]
    ├── Success ──▶ [Continue]
    └── Error ────▶ [Fallback] ──▶ [Sink]

Next Steps