n8n AI Agent Memory: Window vs Postgres vs pgvector (With Template)

n8n AI agent memory is a sub-node you connect to the Memory port of the AI Agent node: Simple Memory keeps the last few exchanges in the n8n process, Postgres Chat Memory stores them in a database table, and a pgvector store attached as a tool lets the agent search older conversations by meaning. Start with Simple Memory, switch to Postgres when chats have to survive a restart, and add pgvector only when the agent must recall something from a past session.

Checked October 2026 against n8n's docs for Simple Memory, Postgres Chat Memory, the PGVector Vector Store and the Chat Trigger, the source of n8n 2.42.6, Supabase's connection and pricing pages, and the Anthropic and OpenAI price lists.

This tutorial is part of our n8n hub. It is the hands-on companion to AI agent memory options compared, which covers window, summary, vector and entity memory in general. Here you build the three that n8n supports out of the box, in one workflow you can import.

How does n8n AI agent memory work?

Every memory node in n8n is a window. On each turn it loads the stored messages for one session, hands the model the most recent ones, and saves the new exchange afterwards. Three settings decide the behaviour:

• Session ID. The key that separates one conversation from another. By default the node reads sessionId from a directly connected Chat Trigger. For any other trigger, choose Define below and pass your own key, such as a phone number or chat ID.
• Context Window Length. How many past interactions the model receives. The default is 5, and one interaction is a user message plus the reply.
• Where it is stored. This is the only real difference between the memory nodes.

Two limits from the docs: only agents can use memory (chains cannot), and sub-node expressions always resolve against the first input item. Here are the three tiers side by side:

Tier 1: the n8n chat memory node (Simple Memory)

Simple Memory is the node to start with: connect it to the agent and conversations work, with no credential. Its own description says why: "Stores in n8n memory, so no credentials required". That is also its limit.

The one-hour rule is in MemoryBufferWindow.node.ts (cleanupStaleBuffers); the n8n docs do not mention it. None of this matters while you are building. Use tier 1 to get the prompt, the tools and the tone right, then swap the memory node. Nothing else in the workflow has to change.

Tier 2: n8n AI agent memory on Supabase (Postgres Chat Memory)

Postgres Chat Memory is the same window, backed by a table. Any Postgres works; Supabase is a convenient host because the same database can hold the vectors in tier 3.

Why the Session pooler: Supabase's docs say the direct connection uses IPv6 unless you buy the IPv4 add-on, while the shared pooler works over IPv4 on every plan, and session mode is the one they recommend for persistent servers on IPv4 networks. n8n is a persistent server.

On SSL: Supabase's docs say to connect with SSL whenever possible, and the n8n Postgres credential defaults to Disable, so change it to Require. If the test then fails on the certificate, the credential's Ignore SSL Issues (Insecure) switch keeps the connection encrypted but skips verifying the server, which is the trade-off its name states.

What n8n writes is simple. The node creates the table if it does not exist, with three columns: id, session_id and message as JSON. Every turn adds two rows. On each call the node reads the whole session and sends the model the last N interactions, so the table keeps growing while the prompt does not. This is your n8n agent conversation history, and you can query it directly:

-- read one conversation
select id, message->>'type' as role, message->>'content' as content
from n8n_chat_histories
where session_id = 'YOUR-SESSION-ID'
order by id;

-- speed up lookups once the table grows (the node only creates a primary key)
create index if not exists n8n_chat_histories_session_idx
  on n8n_chat_histories (session_id);

-- optional: add a timestamp so you can prune old chats
alter table n8n_chat_histories
  add column if not exists created_at timestamptz default now();
delete from n8n_chat_histories
where created_at < now() - interval '90 days';

One Supabase detail to plan around: the pricing page says Free plan projects are paused after one week of inactivity, and paid projects are not. A paused database means an agent with no memory and a failed execution, so give the workflow an error workflow; our Error Trigger guide has one ready to import. If you are new to Supabase itself, start with the Supabase tutorial.

Tier 3: pgvector semantic recall across sessions

A window forgets everything outside it, and a new session starts empty. Tier 3 fixes that with two additions: every finished turn is embedded and saved, and the agent gets a tool that searches those saved turns by meaning.

In n8n this is the Postgres PGVector Store node, used twice with the same Postgres credential as tier 2:

• As a tool. Operation Mode set to Retrieve Documents (As Tool for AI Agent), connected to the agent's Tool port. The Description tells the model when to search, and Limit (default 4) sets how many saved turns come back.
• As a writer. Operation Mode set to Insert Documents, placed after the agent, with a Default Data Loader that turns the exchange into one document.
• With an embeddings model. Both need one. The template uses OpenAI's text-embedding-3-small.

You do not need to prepare the database. The node creates the n8n_vectors table on first use, and the store it is built on runs create extension if not exists vector first. On Supabase you can also switch the extension on yourself under Database, Extensions.

The n8n docs list Metadata Filter under Get Many mode only. In the 2.42.6 source the same option is wired into the tool mode as well (VectorStorePGVector.node.ts), which is what the template relies on.

The template: three tiers in one importable n8n workflow

Copy the JSON, open a new workflow and paste it onto the canvas. Tier 1 is connected and works with one Anthropic credential. Tier 2 sits beside it, ready to swap in. Tier 3 is fully wired but deactivated, so it does nothing until you turn it on. Node types, versions and parameter names come from the n8n 2.42.6 source, and the versions chosen also exist in n8n 2.0.

{
  "name": "AI agent memory: window, Postgres, pgvector",
  "nodes": [
    {
      "parameters": {
        "options": {}
      },
      "id": "d4b9f5c2-0001-4f3e-8b4d-000000000001",
      "name": "When chat message received",
      "type": "@n8n/n8n-nodes-langchain.chatTrigger",
      "typeVersion": 1.3,
      "position": [
        0,
        0
      ],
      "webhookId": "d4b9f5c2-1000-4f3e-8b4d-000000000010"
    },
    {
      "parameters": {
        "options": {
          "systemMessage": "You are a helpful assistant. If you have a long_term_memory tool and the user refers to something from an earlier conversation that is not in this chat, search it before you answer."
        }
      },
      "id": "d4b9f5c2-0002-4f3e-8b4d-000000000002",
      "name": "AI Agent",
      "type": "@n8n/n8n-nodes-langchain.agent",
      "typeVersion": 3,
      "position": [
        240,
        0
      ]
    },
    {
      "parameters": {
        "model": {
          "__rl": true,
          "mode": "id",
          "value": "claude-haiku-5-5"
        },
        "options": {}
      },
      "id": "d4b9f5c2-0003-4f3e-8b4d-000000000003",
      "name": "Anthropic Chat Model",
      "type": "@n8n/n8n-nodes-langchain.lmChatAnthropic",
      "typeVersion": 1.3,
      "position": [
        160,
        220
      ]
    },
    {
      "parameters": {
        "contextWindowLength": 5
      },
      "id": "d4b9f5c2-0004-4f3e-8b4d-000000000004",
      "name": "Simple Memory",
      "type": "@n8n/n8n-nodes-langchain.memoryBufferWindow",
      "typeVersion": 1.3,
      "position": [
        320,
        220
      ]
    },
    {
      "parameters": {
        "tableName": "n8n_chat_histories",
        "contextWindowLength": 5
      },
      "id": "d4b9f5c2-0005-4f3e-8b4d-000000000005",
      "name": "Postgres Chat Memory",
      "type": "@n8n/n8n-nodes-langchain.memoryPostgresChat",
      "typeVersion": 1.3,
      "position": [
        320,
        400
      ]
    },
    {
      "parameters": {
        "mode": "retrieve-as-tool",
        "toolDescription": "Search turns saved from this user's earlier conversations. Use it when the user mentions something that is not in the current chat.",
        "tableName": "n8n_vectors",
        "topK": 4,
        "options": {
          "metadata": {
            "metadataValues": [
              {
                "name": "userId",
                "value": "={{ $json.sessionId }}"
              }
            ]
          }
        }
      },
      "id": "d4b9f5c2-0006-4f3e-8b4d-000000000006",
      "name": "long_term_memory",
      "type": "@n8n/n8n-nodes-langchain.vectorStorePGVector",
      "typeVersion": 1.3,
      "position": [
        500,
        220
      ],
      "disabled": true
    },
    {
      "parameters": {
        "model": "text-embedding-3-small",
        "options": {}
      },
      "id": "d4b9f5c2-0007-4f3e-8b4d-000000000007",
      "name": "Embeddings OpenAI",
      "type": "@n8n/n8n-nodes-langchain.embeddingsOpenAi",
      "typeVersion": 1.2,
      "position": [
        600,
        420
      ],
      "disabled": true
    },
    {
      "parameters": {
        "mode": "insert",
        "tableName": "n8n_vectors",
        "options": {}
      },
      "id": "d4b9f5c2-0008-4f3e-8b4d-000000000008",
      "name": "Save turn",
      "type": "@n8n/n8n-nodes-langchain.vectorStorePGVector",
      "typeVersion": 1.3,
      "position": [
        640,
        0
      ],
      "disabled": true
    },
    {
      "parameters": {
        "jsonMode": "expressionData",
        "jsonData": "=User: {{ $('When chat message received').first().json.chatInput }}\nAssistant: {{ $json.output }}",
        "options": {
          "metadata": {
            "metadataValues": [
              {
                "name": "userId",
                "value": "={{ $('When chat message received').first().json.sessionId }}"
              }
            ]
          }
        }
      },
      "id": "d4b9f5c2-0009-4f3e-8b4d-000000000009",
      "name": "Turn as document",
      "type": "@n8n/n8n-nodes-langchain.documentDefaultDataLoader",
      "typeVersion": 1.1,
      "position": [
        760,
        220
      ],
      "disabled": true
    },
    {
      "parameters": {
        "assignments": {
          "assignments": [
            {
              "id": "d4b9f5c2-2000-4f3e-8b4d-000000000020",
              "name": "output",
              "value": "={{ $('AI Agent').first().json.output }}",
              "type": "string"
            }
          ]
        },
        "options": {}
      },
      "id": "d4b9f5c2-0010-4f3e-8b4d-000000000011",
      "name": "Reply",
      "type": "n8n-nodes-base.set",
      "typeVersion": 3.4,
      "position": [
        880,
        0
      ]
    }
  ],
  "connections": {
    "When chat message received": {
      "main": [
        [
          {
            "node": "AI Agent",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "AI Agent": {
      "main": [
        [
          {
            "node": "Save turn",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Save turn": {
      "main": [
        [
          {
            "node": "Reply",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Anthropic Chat Model": {
      "ai_languageModel": [
        [
          {
            "node": "AI Agent",
            "type": "ai_languageModel",
            "index": 0
          }
        ]
      ]
    },
    "Simple Memory": {
      "ai_memory": [
        [
          {
            "node": "AI Agent",
            "type": "ai_memory",
            "index": 0
          }
        ]
      ]
    },
    "long_term_memory": {
      "ai_tool": [
        [
          {
            "node": "AI Agent",
            "type": "ai_tool",
            "index": 0
          }
        ]
      ]
    },
    "Embeddings OpenAI": {
      "ai_embedding": [
        [
          {
            "node": "long_term_memory",
            "type": "ai_embedding",
            "index": 0
          },
          {
            "node": "Save turn",
            "type": "ai_embedding",
            "index": 0
          }
        ]
      ]
    },
    "Turn as document": {
      "ai_document": [
        [
          {
            "node": "Save turn",
            "type": "ai_document",
            "index": 0
          }
        ]
      ]
    }
  },
  "settings": {
    "executionOrder": "v1"
  }
}

Two design notes. The last node, Reply, exists because the Chat Trigger answers with the output of the last node that ran; the n8n docs say a manual reply must be a field named output or text, so Reply copies the agent's answer back into output after the save step. And Save turn stores every exchange, including "thanks". Once the basics work, put an If node in front of it and skip short turns, or your searches fill up with noise.

What does each tier cost per 1,000 conversations?

Mostly input tokens, because the window is sent again on every turn. Storage barely registers. The table below is arithmetic on published prices, not a measurement, and every input is an assumption you should replace with your own.

• Tiers 1 and 2 cost the same in tokens. Postgres adds a database bill, which is a plan price and not a per-conversation fee. On Supabase that is the Free plan with 500 MB per project, or Pro from $25 a month with 8 GB of disk (checked October 2026).
• The window is the dial. With these inputs, raising Context Window Length from 5 to 10 lifts input from 11.0M to 13.0M tokens. In longer conversations the gap widens, because the window stays full for more turns.
• Embeddings are nearly free. Saving and searching 1,000 conversations costs about four cents. The price of recall is the extra model call and the saved turns it reads, about 71 cents of the Haiku total.
• The model outweighs the memory. Every row is about 20 times higher on Sonnet 5.5. Pick the memory tier for what the agent must remember and the model for how hard the task is.

Our Claude API pricing breakdown covers caching and batch discounts, which change these numbers further. When memory, retrieval and model choice turn into product decisions, the AI SaaS Builder program goes deeper: it covers Supabase from schema to Row Level Security, and adding RAG with embeddings and pgvector to an app you ship.

Troubleshooting n8n agent memory

• "No sessionId". The memory node expects a sessionId from a connected Chat Trigger. With a Webhook, WhatsApp or Telegram trigger, set Session ID to Define below and pass your own key.
• The agent mixes up two conversations. Both are using the same session key. The docs warn that several memory nodes in one workflow share one memory instance unless you give them different session IDs.
• The agent forgets mid-conversation. Either Context Window Length is too low for the task, or you are on Simple Memory and the process restarted.
• Memory works in the editor and fails in production. Simple Memory with queue mode. Move to Postgres or Redis memory.
• Supabase connection times out. Check whether you used the direct connection host from a network without IPv6. Use the Session pooler host and the user with the project reference.
• The search tool is never called. Sharpen its Description and name the tool in the system message, as the template does.

If you would rather run the whole stack on your own machine first, n8n's self-hosted kit bundles a PostgreSQL database you can point tier 2 at, and ships Qdrant as its vector store; our AI starter kit guide explains what is in it.

n8n AI agent memory: FAQ