How to Fix Duplicate Conversation Threads with Gemini Agents in n8n

In the n8n AI Agent node, the Memory sub-node stores and retrieves conversation history. Each conversation is identified by a session ID. When a request arrives, the Memory sub-node looks up existing messages for that session ID and includes them in the context sent to Gemini. If the session ID changes between requests from the same user, the Memory sub-node cannot find the previous conversation, so it starts a new thread. The default behavior uses the execution ID as the session key, which is unique per execution and therefore always creates new threads. To fix this, you must provide a stable session ID that persists across multiple requests from the same user.

Your webhook caller (chat frontend, Slack, WhatsApp, etc.) must send a user or session identifier with each request. Common patterns include a userId in the request body, a session token in a header, or a chat_id from messaging platforms. Add a Code node after the Webhook that extracts this identifier and ensures it is always present. If no identifier is provided, generate a fallback based on the IP address or a hash of available request metadata. The key requirement is that the same user always produces the same session ID across multiple requests.

1// Code node: Extract Session ID
2// Mode: Run Once for All Items
3
4const items = $input.all();
5const results = [];
6
7for (const item of items) {
8  const body = item.json.body || item.json;
9  const headers = item.json.headers || {};
10
11  // Try multiple sources for session ID
12  let sessionId = body.sessionId
13    || body.userId
14    || body.chat_id
15    || headers['x-session-id']
16    || headers['x-user-id'];
17
18  // Fallback: hash IP + User-Agent for anonymous users
19  if (!sessionId) {
20    const ip = headers['x-forwarded-for'] || headers['x-real-ip'] || 'unknown';
21    const ua = headers['user-agent'] || 'unknown';
22    // Simple hash
23    let hash = 0;
24    const str = ip + ua;
25    for (let i = 0; i < str.length; i++) {
26      const char = str.charCodeAt(i);
27      hash = ((hash << 5) - hash) + char;
28      hash = hash & hash;
29    }
30    sessionId = 'anon_' + Math.abs(hash).toString(36);
31  }
32
33  results.push({
34    json: {
35      ...item.json,
36      sessionId: sessionId,
37      userMessage: body.message || body.text || body.content || ''
38    }
39  });
40}
41
42return results;

In the AI Agent node, click on the Memory sub-node (e.g., Window Buffer Memory or Postgres Chat Memory). Look for the Session ID field or Session Key field. Set it to an expression that references the session ID from the upstream Code node: {{ $json.sessionId }}. This tells the Memory sub-node to use your extracted session ID instead of generating a new one per execution. For Window Buffer Memory (in-memory), note that sessions are lost when n8n restarts. For production, use Postgres Chat Memory or Redis Chat Memory which persist across restarts. The session ID expression must resolve to a non-empty string; if it resolves to undefined, the Memory node falls back to the execution ID.

1// In the Memory sub-node Session ID field:
2{{ $('Extract Session ID').first().json.sessionId }}
3
4// Or if the Code node is the immediately previous node:
5{{ $json.sessionId }}

Replace the default Window Buffer Memory with Postgres Chat Memory for production use. Add a Postgres Chat Memory sub-node to the AI Agent. Configure the PostgreSQL connection using your database credentials. The node automatically creates a table to store conversation messages indexed by session ID. Set the Session ID field to your extracted session ID expression. Set the Context Window Length to control how many previous messages are included in each Gemini call (10-20 is typical). The Postgres Chat Memory persists across n8n restarts and supports multiple concurrent users, each with their own conversation thread identified by their session ID.

Over time, abandoned sessions accumulate in your memory store. Add a scheduled cleanup workflow that removes sessions older than a configurable threshold (e.g., 24 hours). Use a Cron Trigger node set to run daily, connected to a Postgres node that deletes records where the last message timestamp is older than the threshold. This prevents your memory table from growing indefinitely and avoids situations where a user returns after weeks and gets confusing context from an old conversation. Also consider adding a 'reset' command that users can send to explicitly clear their session.

1// Code node: Check for reset command
2const items = $input.all();
3
4for (const item of items) {
5  const message = (item.json.userMessage || '').trim().toLowerCase();
6  item.json.shouldResetSession = (
7    message === '/reset' ||
8    message === '/new' ||
9    message === '/clear'
10  );
11}
12
13return items;
14
15// Follow with IF node:
16// True branch → Postgres DELETE WHERE session_id = sessionId
17// False branch → Continue to AI Agent

If duplicate threads persist after configuration, add a diagnostic Code node that logs the session ID at each step. Place it before the AI Agent node and check the execution data to verify the session ID is consistent across multiple requests from the same user. Common issues include: the session ID field name changing between requests (sessionId vs session_id), the webhook body being nested differently for different callers, or the Memory sub-node expression not resolving correctly. Compare the session ID in consecutive executions from the same user; they must be identical for the Memory node to find the existing thread.

1// Code node: Session Diagnostic Logger
2const item = $input.first().json;
3
4console.log('=== SESSION DIAGNOSTIC ===');
5console.log('Session ID:', item.sessionId);
6console.log('Session ID type:', typeof item.sessionId);
7console.log('Session ID length:', (item.sessionId || '').length);
8console.log('User message:', (item.userMessage || '').substring(0, 50));
9console.log('Execution ID:', $execution.id);
10console.log('========================');
11
12// Validate session ID
13if (!item.sessionId || item.sessionId === 'undefined') {
14  throw new Error('Session ID is missing or undefined. Check upstream extraction logic.');
15}
16
17return [$input.first()];