How to handle multi-turn conversations failing with Cohere in n8n?

When multi‑turn conversations fail with Cohere in n8n, the root cause is almost always that the conversation history you send to Cohere is too large, malformed, or not structured the way Cohere expects. n8n doesn’t maintain conversation state for you — you must build and store the history yourself, usually in a database or a workflow static data object. Production‑safe multi‑turn means: store history externally, trim or summarize messages to avoid token limits, and always build a clean array of messages before sending it to the Cohere node.

 

What actually goes wrong in n8n with Cohere multi‑turn

 

Most failures come from:

• Sending the entire raw n8n JSON as history instead of a clean array of text messages.
• Conversation history growing too large, exceeding Cohere’s token limit.
• Messages stored incorrectly (mixed objects, unexpected fields).
• Mistakes in how expressions reference previous messages (null values, arrays inside arrays, etc.).
• Using the Cohere node without clearing system fields that Cohere’s API doesn’t expect.

So the fix is always: store history yourself, sanitize it, and control its size.

 

A production‑ready approach

 

The safest pattern is:

• Store the conversation history in a database (Postgres, MySQL, Supabase) or in Workflow Static Data if the volume is small.
• Each time the user sends a message, fetch the stored history, append the new user message, and optionally trim or summarize it.
• Send to Cohere only the clean list of messages you want the model to see.
• Store the model’s reply back in the same history store.

This avoids exceeding limits and gives you full control of structure.

 

How to implement this in n8n (safe pattern)

 

Below is an example using Workflow Static Data (works for light production). Database works the same, just replace the read/write step.

• A Function node initializes or updates the history.
• You pass a trimmed array to the Cohere node.
• You store the output back.

 

// This runs in a Function node before calling Cohere

// Load existing history from static data
let history = this.getWorkflowStaticData('global').history || []

// Get incoming user message
const userMessage = items[0].json.userMessage

// Append user message
history.push({ role: 'user', content: userMessage })

// Keep history small
history = history.slice(-10)  // keep last 10 messages only

// Save back
this.getWorkflowStaticData('global').history = history

// Output for next node
return [{ json: { messages: history } }]

 

You then feed {{ $json.messages }} into the Cohere Chat node.

After Cohere responds, you append the assistant reply the same way:

 

// In a Function node after Cohere response

let history = this.getWorkflowStaticData('global').history || []

const assistantReply = items[0].json.ai_output  // Adjust field name to your Cohere node output

history.push({ role: 'assistant', content: assistantReply })
history = history.slice(-10)

this.getWorkflowStaticData('global').history = history

return items

 

Important Cohere‑specific notes

 

• Cohere expects a list of messages structured as: role: "user" or "assistant", and content as plain text.
• Do not include n8n’s internal JSON; Cohere cannot parse nested structures.
• Control total message length — Cohere has strict token limits depending on model.
• If your conversation is long: summarize periodically and keep only the summary + last few turns.

 

What NOT to do

 

• Do not pass all previous n8n node outputs directly to Cohere.
• Do not rely on n8n to maintain history automatically; it won’t.
• Do not store history inside the incoming webhook payload; it will break over time.
• Do not skip trimming — that’s the #1 cause of “multi‑turn fails”.

 

Short direct answer

 

Multi‑turn conversations fail with Cohere in n8n because you must manually manage conversation history — n8n does not do it for you. Store history yourself (static data or database), build a clean array of user/assistant messages before each Cohere call, trim or summarize the history to avoid token limits, and re‑save the reply back into your history storage. This makes Cohere multi‑turn stable in production.