How to Handle Multi-Turn Conversations Failing with Cohere in n8n

Add a Postgres Chat Memory node to your workflow. This node stores conversation messages in a PostgreSQL table with session IDs, allowing you to retrieve history per user. Configure it with your PostgreSQL credentials, set the Session ID to a dynamic value from your Webhook (e.g., {{ $json.userId }} or {{ $json.sessionId }}), and set the Context Window Length to 20 messages. The memory node stores messages in a generic format — we will transform them for Cohere in the next step.

Add a Code node after your memory retrieval step. The n8n memory nodes return messages in a format like [{role: 'user', content: 'hello'}, {role: 'assistant', content: 'hi'}]. Cohere expects chat_history as [{role: 'USER', message: 'hello'}, {role: 'CHATBOT', message: 'hi'}]. The Code node maps between these formats, converting role names and field names to match Cohere's API specification.

1// Code node — JavaScript
2// Transform n8n memory format to Cohere chat_history format
3
4const items = $input.all();
5const memoryMessages = items[0].json.memory || items[0].json.messages || [];
6
7// Map n8n roles to Cohere roles
8const roleMap = {
9  'user': 'USER',
10  'human': 'USER',
11  'assistant': 'CHATBOT',
12  'ai': 'CHATBOT',
13  'system': 'SYSTEM'
14};
15
16const chatHistory = memoryMessages
17  .filter(msg => msg.role !== 'system') // Cohere uses preamble, not system in history
18  .map(msg => ({
19    role: roleMap[msg.role?.toLowerCase()] || 'USER',
20    message: msg.content || msg.text || msg.message || ''
21  }));
22
23// Current user message is sent separately, not in chat_history
24const currentMessage = items[0].json.currentMessage
25  || items[0].json.message
26  || items[0].json.text
27  || '';
28
29return [{
30  json: {
31    chatHistory,
32    currentMessage,
33    sessionId: items[0].json.sessionId || 'default'
34  }
35}];

Add an HTTP Request node and configure it to call Cohere's Chat endpoint. Set the method to POST, the URL to https://api.cohere.ai/v1/chat, and add headers for Authorization (Bearer your-api-key) and Content-Type (application/json). In the body, use the transformed chatHistory as the chat_history field, the currentMessage as the message field, and optionally set a preamble for system instructions. The preamble acts as Cohere's equivalent of a system message.

1// HTTP Request node body (JSON)
2{
3  "model": "command-r-plus",
4  "message": "{{ $json.currentMessage }}",
5  "chat_history": {{ JSON.stringify($json.chatHistory) }},
6  "preamble": "You are a helpful assistant. Answer questions clearly and concisely.",
7  "temperature": 0.3,
8  "max_tokens": 1024,
9  "conversation_id": "{{ $json.sessionId }}"
10}

After receiving Cohere's response, you need to store both the user message and the assistant response in your memory node for the next turn. Add a Code node that formats the new messages for the Postgres Chat Memory node. The memory node expects messages with role and content fields. Extract the response text from Cohere's response (located at $json.text in the API response) and pass both messages to the memory node's input.

1// Code node — JavaScript
2// Prepare messages to store in memory
3
4const cohereResponse = $input.all()[0].json;
5const userMessage = $('Transform History').first().json.currentMessage;
6const assistantMessage = cohereResponse.text || '';
7
8return [
9  {
10    json: {
11      action: 'store',
12      messages: [
13        { role: 'user', content: userMessage },
14        { role: 'assistant', content: assistantMessage }
15      ],
16      sessionId: $('Transform History').first().json.sessionId,
17      responseText: assistantMessage
18    }
19  }
20];

Cohere's chat_history can grow large over long conversations, eventually exceeding token limits. Add logic to your transformation Code node to trim the history to the most recent N messages while always preserving the first message (which often contains important context). A good default is 20 messages (10 turns). This prevents 'context length exceeded' errors and keeps API costs predictable.

1// Add to your Transform History Code node
2const MAX_HISTORY = 20;
3
4let trimmedHistory = chatHistory;
5if (chatHistory.length > MAX_HISTORY) {
6  // Keep first message + most recent messages
7  const first = chatHistory[0];
8  const recent = chatHistory.slice(-(MAX_HISTORY - 1));
9  trimmedHistory = [first, ...recent];
10}
11
12// Use trimmedHistory instead of chatHistory in output

Test the complete workflow by sending multiple messages with the same sessionId through your Webhook. Send at least three messages in sequence and verify that Cohere's responses reference information from earlier in the conversation. Check the Postgres Chat Memory table directly to confirm messages are stored with correct roles and session IDs. Use n8n's execution history to inspect the chatHistory array at each turn and verify it grows correctly.