AI Node

Puts a language model in the middle of a flow. At its simplest it takes a payload, runs a prompt, and passes the answer downstream. At its most involved it is an agent: it decides which of your other nodes to call, remembers previous conversations, and returns a validated object rather than prose. The panel is organised in tabs, and so is this page.

ℹEvery call is billed against your provider credential. HostWebhook does not proxy through a shared key, and a node inside a Loop is one call per item.

Config — provider, credential, prompts

Provider and credential

Four providers: Anthropic, OpenAI, Google and Ollama. Picking one filters the credential picker to keys of that type; switching provider clears the selected credential, because a key from one is meaningless to another. Ollama points at your own host, so it is the path for models that never leave your infrastructure.

System prompt and user message

The system prompt sets the role and the rules and is usually static. The user message is where the payload goes, through the same templating as everywhere else: {{payload.question}}, or a reference to another node's output. Both boxes autocomplete the fields the incoming payload actually has.

Audio transcription

Optional. When the payload carries an audio file, the node can transcribe it first and feed the text to the prompt — which is what turns “a voice note arrived” into a flow you can act on.

Settings

Max tokens — leave empty for the model default. It caps the answer, not the prompt.
Temperature — 0 to 1, in steps of 0.05. Low for extraction and classification, higher for drafting. The range is deliberately 0–1 across the whole dashboard even where a provider would accept more, so a value means the same thing whichever model you pick.

Summarization

Turns the node into a text summariser with a strategy chosen for the size of the input:

Strategy	How it works
Off	Normal node. The default.
Auto	Picks the cheapest strategy that fits the input.
Stuff	One call with everything in it. Cheapest, only works when it fits.
Map-Reduce	One call per chunk in parallel, then a call to merge. Fast on long inputs.
Refine	Walks the chunks in order, carrying the summary forward. Slower, keeps narrative continuity.

⚠Summarisation disables tools, memory and structured output. A summary is free-form text by definition, so a JSON schema configured in the Output tab is ignored while a strategy is active. If the Output tab looks inert, check that Summarization is Off.

Output — four modes

Mode	You get	Use for
Text	`aiResponse` with the prose	Replies, drafts, summaries
JSON	The parsed object, spread at the top level	Free-form extraction
Structured	An object validated against a schema you define	Anything a later node depends on by field name
Classifier	One of the categories you list	Routing: triage, sentiment, intent

Prefer Structured over JSON whenever something downstream reads a specific field. JSON mode trusts the model to keep its shape; structured mode makes the shape a contract, and a parse failure becomes visible instead of arriving as prose in a field that expected a number.

What downstream nodes receive

jsonOutput payload

{
  "_meta": { "iterable": false, "count": 1 },
  "sentiment": "negative",
  "urgency": 4
}

The payload handed downstream is clean: every key the node uses for its own bookkeeping — tool calls, token counts — is stripped, so your templates read {{payload.sentiment}} and not a nested debug structure. When a JSON parse fails, the raw text comes through as aiResponse and _meta.parseError is set — worth a Filter node if the flow must not continue on garbage.

ℹThe chat widget and the trace panel see a richer shape, with _toolCalls and _tokens, because they exist to show that bookkeeping. Same call, two representations, on purpose.

Tools — what the model is allowed to do

Tools turn the node from “answer this” into an agent. The model decides which to call, with what arguments, and how many times. Seven kinds can be attached:

Built-in tools — the ones HostWebhook ships.
Custom HTTP tools — a URL, a method, and the parameters you declare. There is a “let AI handle path and method” switch for APIs where the model should choose the route.
Node tools — another node in the workspace exposed as a callable. This is how an agent sends an email or writes a row.
MCP servers — a credential returns a catalogue of tools.
Tunnel tools — the same, over a reverse tunnel to a private host.
Vector Stores — each store becomes a query_<store> tool. See Vector Stores.
Voice synthesis — lets the agent speak its answer.

⚠A node only appears in the picker if it has been made available to AI — exposure is opt-in per node, not automatic. If a node you expect is missing from the list, enable it on that node first.

Guardrails

Two layers, and they are not the same thing:

Auto-applied — derived from the tools you attached. Give the agent a toolkit that can delete, and the matching rules appear on their own.
Agent guardrails — a checklist you opt into, spelling out what the agent must not do.
Block destructive tool calls — a hard switch in the Security tab. With it on, a tool annotated as destructive is refused rather than argued with.

The panel nags with a banner when an agent has tools and no guardrails. That is deliberate: prompt text is a request, a blocked call is a rule.

Memory — four backends

Off by default. Turned on, the node recalls previous exchanges for the same session id — usually {{payload.sessionId}}, whatever identifies one conversation in your data.

Backend	Where it lives	Counts against your plan
Built-in	Managed by HostWebhook, semantic recall	Yes — text counts toward managed storage
ContextWindow	Your ContextWindow account, via API key	No
External MongoDB	Your cluster, collection you name	No
External PostgreSQL	Your cluster, table you name	No

Alongside the backend: recall limit (how many past records enter the prompt), max records per session (when to start forgetting), and ingest mode (what gets written back).

ℹMemory is not the same feature as a Vector Store. Memory is per-conversation and written by the node itself; a vector store is a corpus you curate and query. They live in different collections and are configured in different places.

Logs and audit

AI call logs — every call with its prompt, answer and token counts.
Tool call audit — what the agent invoked, with arguments, result and duration. The first place to look when an agent did something surprising.
Signals worth investigating — the panel's own reading of the logs: repeated failures, tools that always error, calls that stand out.

Gotchas

Text mode and Output mode used to fight. The canonical field is the Output tab's mode; if an old node behaves as though it were still returning JSON, re-pick the mode there once.
An agent with no guardrails will do what the prompt asks. Including the parts you did not mean literally. Attach the checklist.
Memory recall costs tokens on every call — each recalled record is prompt input you pay for. Keep the recall limit honest.
A tool the model never calls is usually a description problem. The model reads only the tool's name and description when deciding. Both are editable; make them say when to use it.