mem0-self

n8n community node for Mem0 Self-Hosted with LangChain-compliant AI memory

Package Information

Downloads: 1,356 weekly / 1,356 monthly
Latest Version: 0.2.13
Author: Amaral Karl

Available Nodes

Mem0 Chat Memory icon
Mem0 Chat Memory
Persistent chat memory for AI Agent using Mem0 Self-Hosted OSS REST API

Documentation

n8n-nodes-mem0-self

��� Mem0 Self-Hosted Memory Node for n8n (v0.2.13)

⚠️ IMPORTANT: This is an independent, community-maintained package for Mem0 Self-Hosted OSS only. It has NO affiliation with Mem0 Inc. and is NOT officially supported by Mem0. Use at your own risk.

Table of Contents

  1. Overview
  2. What's New in v0.2.13
  3. Quick Start
  4. Installation
  5. Credentials Setup
  6. Node Parameters (Complete Reference)
  7. Field Importance Guide
  8. Performance & Token Optimization
  9. Recommended Configurations
  10. Troubleshooting
  11. Safety & Security
  12. License

Overview

n8n-nodes-mem0-self provides a memory integration node for n8n AI Agent workflows using Mem0 Self-Hosted (OSS REST API).

Key Features

✅ 100% Self-Hosted: No cloud dependency. Full control of your memory data.
✅ Persistent Conversation Memory: Stores and retrieves multi-turn AI conversations.
✅ Semantic Search: Intelligent context retrieval using embeddings.
✅ Scoped Isolation: Memory partitioned by user, agent, and session.
✅ Token Optimized: Sliding window buffer reduces 95% token consumption after 1st turn.
✅ Production Ready: TypeScript, type-safe, fully tested.

What This Node Does

┌─────────────────────────────────────────────────────────┐
│  Your n8n Workflow                                      │
│                                                          │
│  ┌─────────────┐      ┌──────────────────┐             │
│  │  AI Agent   │────→ │ Mem0 Chat Memory │             │
│  └─────────────┘      └────────┬─────────┘             │
│                                │                        │
│  • Stores: User + AI messages  ├─→ Mem0 Self-Hosted   │
│  • Retrieves: Relevant context │   (Your Server)      │
│  • Isolated: Per user/agent    │                       │
└──────────────────────────────────────────────────────────┘

What's New in v0.2.13

��� Major Release: Sliding Window Memory Optimization

Performance Gains

Metric Before After (Turn 2+) Improvement
Messages fetched 40 every turn 1 per turn 97.5% ↓
Token consumption ~4000 tokens ~200 tokens 95% ↓
API calls Every interaction 1st only Massive ↓
Memory efficiency Linear growth Constant window Optimized

How It Works

1st Interaction: Load full buffer

Message Buffer: [msg0, msg1, msg2, ..., msg39]  (40 messages)
                 │                               │
                 └── bufferLimit × 2 ────────────┘

2nd+ Interactions: Sliding window (remove oldest 2, add newest 1)

Turn 2: [msg2, msg3, msg4, ..., msg40]  (removed [0,1], added msg40)
Turn 3: [msg4, msg5, msg6, ..., msg41]  (removed [2,3], added msg41)
Turn 4: [msg6, msg7, msg8, ..., msg42]  (removed [4,5], added msg42)

Technical Details

  • Scope: Global per user+agent combo (cache shared across sessions)
  • Storage: First interaction only (subsequent loads are incremental)
  • Cache Key: ${user_id}|${agent_id} (no run_id)
  • Invalidation: After each saveContext() call

Breaking Changes

✅ NONE - This is a transparent performance optimization.

Quick Start (3 minutes)

1. Install Community Node

In n8n:

Settings → Community Nodes → Install
Package: n8n-nodes-mem0-self
Restart n8n

2. Create Credentials

In n8n:

Credentials → New → Mem0 Self-Hosted API
Base URL: http://localhost:8000  (or your Mem0 server)
API Key: (your X-API-Key)

3. Wire Your Workflow

Trigger
  ↓
AI Agent
  ├→ ai_languageModel: Chat Model node
  └→ ai_memory: Mem0 Chat Memory node

4. Configure Memory Node

Field Example Value
User ID user_123
Agent ID support_bot
Run ID conversation_456 (optional)
Buffer Limit 20

5. Test It

  1. Ask the AI a question with a personal fact: "My name is Alice"
  2. Ask another question: "What's my name?"
  3. AI should recall: "Your name is Alice"

✅ Memory is working!

Installation

Via n8n Community Nodes (Recommended)

  1. Open n8n
  2. Go to Settings → Community Nodes
  3. Click Install
  4. Enter: n8n-nodes-mem0-self
  5. Restart n8n

Manual Installation

npm install n8n-nodes-mem0-self@latest

Then restart n8n.

Local Development

git clone https://github.com/kallbuloso/n8n-nodes-mem0-self.git
cd n8n-nodes-mem0-self
npm install
npm run build

Credentials Setup

Credential Type: Mem0 Self-Hosted API

Required Fields

Field Purpose Example
Base URL Mem0 REST API endpoint http://localhost:8000
API Key Authentication token (X-API-Key header) your-secret-key

Testing Credentials

After creating credentials, verify connection:

curl -X GET http://localhost:8000/health \
  -H "X-API-Key: your-secret-key"

Expected: 200 OK

Node Parameters (Complete Reference)

Identity & Scope (Required)

User ID (userId)

  • Type: String
  • Required: ✅ YES
  • Purpose: Unique identifier of the end user
  • Impact: Isolates memory by user
  • ⚠️ CRITICAL: Incorrect value will mix memory between users
  • Example: "user_alice@company.com", "user_123", "alice" (must be unique per user)
  • Best Practice: Use stable identifier (email, UUID, or fixed ID)

Agent ID (agentId)

  • Type: String
  • Required: ✅ YES
  • Purpose: Identifier of the AI agent/persona
  • Impact: Isolates memory per assistant/agent
  • ⚠️ CRITICAL: Different agents should have different IDs
  • Example: "support_bot", "sales_assistant", "qa_agent"
  • Best Practice: Use meaningful names (helps with debugging)

Run ID (runId)

  • Type: String
  • Required: ❌ NO (but highly recommended)
  • Purpose: Session/conversation identifier for strict boundaries
  • Impact: Allows memory isolation per conversation
  • Examples: "session_789", "conversation_2024_04_17", "thread_xyz"
  • When to use:
    • Multi-session applications (chat history per conversation)
    • A/B testing (separate memory per test run)
    • Compliance (audit trail per conversation)
  • When to skip: Single conversation per user workflows
  • Recommendation: Use it for production safety

Retrieval Strategy (Buffer Mode)

Buffer Limit (Interactions) (bufferLimit)

  • Type: Number
  • Required: ❌ NO
  • Default: 20
  • Range: 1 - 100
  • Purpose: How many user+assistant pairs to load from recent history
  • Technical: bufferLimit = 20 → Load 40 messages (20 pairs × 2)
  • Impact on Performance:
    • bufferLimit = 5: ~200 tokens/turn (fast, low context)
    • bufferLimit = 20: ~800 tokens/turn (balanced, recommended)
    • bufferLimit = 50: ~2000 tokens/turn (slow, high context)
  • ⚠️ Important: With v0.2.13, only 1st turn loads full buffer. Subsequent turns: only 1 message fetched!
  • Recommendation: Start with 20, tune based on AI quality

Fallback to Search on Buffer Miss (fallbackToSearchOnBufferMiss)

  • Type: Boolean
  • Required: ❌ NO
  • Default: true
  • Purpose: If recent buffer seems unrelated to query, search semantic memory
  • When it triggers:
    • User asks about something NOT in recent buffer
    • Semantic search finds better context
  • Impact: Prevents missing important old context
  • Recommendation: Leave true (improves recall quality)

Search Mode (searchMode)

  • Type: Dropdown
  • Required: ❌ NO
  • Default: balanced
  • Options:
    • balanced: Best for general use (recommended)
    • strict_facts: Prioritize factual accuracy
    • legacy: Backward compatibility mode
  • Recommendation: Use balanced unless you need specific behavior

Top K (topK)

  • Type: Number
  • Required: ❌ NO
  • Default: 10
  • Range: 1 - 50
  • Purpose: Max number of search results to retrieve
  • Impact on Quality vs Speed:
    • topK = 3: Fast, lean (300-600 tokens)
    • topK = 10: Balanced (700-1200 tokens)
    • topK = 20: Rich context (1500+ tokens)
  • Recommendation: Start with 10

Storage Controls

Store Strategy (storeStrategy)

  • Type: Dropdown
  • Required: ❌ NO
  • Default: conversation
  • Options:
    • conversation: Store full human+AI pairs (recommended)
    • facts_only: Extract and store facts only
  • Impact: Affects long-term memory quality
  • Recommendation: Use conversation for multi-turn AI

Infer on Store (infer)

  • Type: Boolean
  • Required: ❌ NO
  • Default: false
  • Purpose: Enable Mem0's inference/extraction during storage
  • When to use:
    • Complex semantic extraction needed
    • Advanced use cases (slower)
  • Recommendation: Leave false for speed

Context Size & Quality

Max Context Characters (maxContextChars)

  • Type: Number
  • Required: ❌ NO
  • Default: 700
  • Purpose: Hard cap on memory payload size
  • Impact: Directly controls token growth
  • Token math: 700 chars ≈ 150-200 tokens
  • Tuning:
    • 500: Small, focused context
    • 700: Balanced (recommended)
    • 1500: Large context (more tokens)
  • Recommendation: 700 for most use cases

Default Query (defaultQuery)

  • Type: String
  • Required: ❌ NO
  • Purpose: Fallback search query when user input is empty
  • When used: Edge cases where n8n can't extract user query
  • Example: "Tell me about the user"
  • Recommendation: Leave empty (system handles fallback)

Allow Empty Context (allowEmptyContext)

  • Type: Boolean
  • Required: ❌ NO
  • Default: false
  • Purpose: Allow empty memory without forcing fallback search
  • When to use: Strict control over memory behavior
  • Recommendation: Leave false

Advanced Options

Rerank (rerank)

  • Type: Boolean
  • Default: false
  • Purpose: Enable Mem0 reranking for search results
  • Impact: Better relevance (slower, higher cost)
  • Recommendation: false for speed

Include Assistant Memories (includeAssistantMemories)

  • Type: Boolean
  • Default: false
  • Purpose: Include AI-generated memories in retrieval
  • When to use: Need full dialog context
  • Recommendation: false (user facts are usually more important)

Search Filters (JSON) (searchFilters)

  • Type: JSON String
  • Purpose: Metadata filters for precise retrieval
  • Example: 
    {
  "category": "user_preferences",
  "priority": "high"
}
  • Recommendation: Leave empty unless you need filtering

Fields (Comma Separated) (fields)

  • Type: String
  • Purpose: Custom response fields from Mem0
  • Example: "id,content,created_at,metadata"
  • Recommendation: Leave empty (default fields sufficient)

Field Importance Guide

��� CRITICAL (Must Configure)

  • User ID: Wrong value = mixed user memory
  • Agent ID: Wrong value = shared agent memory

��� HIGH (Should Configure)

  • Buffer Limit: Controls token usage significantly
  • Run ID: Prevents cross-session contamination
  • Store Strategy: Affects long-term memory quality

��� MEDIUM (May Configure)

  • Fallback to Search: Improves context recall
  • Max Context Characters: Controls token budget
  • Search Mode: Fine-tunes retrieval quality

��� LOW (Optional Tuning)

  • Top K: Adjust based on context needs
  • Infer on Store: Advanced feature
  • Rerank: Quality vs speed tradeoff

Performance & Token Optimization

v0.2.13: Sliding Window Optimization

Memory Loading Strategy

                    v0.2.12 (OLD)              v0.2.13 (NEW)
                                            
Turn 1:  Fetch: 40 msgs      ---------->  Fetch: 40 msgs
         Load: 40 msgs                    Load: 40 msgs
         Cache: No                        Cache: Yes ✓
         
Turn 2:  Fetch: 40 msgs      ---------->  Fetch: 1 msg
         Load: 40 msgs                    Load: [msg2...msg40]
         Duplicate: YES ✗                 Duplicate: NO ✓
         
Turn 3:  Fetch: 40 msgs      ---------->  Fetch: 1 msg
         Load: 40 msgs                    Load: [msg4...msg41]
         Efficiency: LOW ✗                Efficiency: 97.5% ↑ ✓

Cost Comparison (5-turn conversation)

Metric Old v0.2.12 New v0.2.13 Savings
Total messages 200 44 78% ↓
Total tokens 20,000 1,200 94% ↓
API calls 5 1 80% ↓
Time 2.5s 0.5s 80% ↓

Tuning Token Usage

Scenario: High-volume chatbot (100 conversations/hour)

Base costs per turn:
  • Turn 1: 1000 tokens (full buffer load)
  • Turns 2-20: 200 tokens each (sliding window)
  
Total per conversation: ~4800 tokens

With v0.2.13:
  Old: 100 convs × 5 turns × 800 tokens = 400K tokens/hour
  New: 100 convs × (1000 + 4×200) = 180K tokens/hour
  Savings: 55% ↓

Recommended Configurations

Configuration A: Lightweight (Low Token Usage)

Use case: Chatbots, customer support, high-volume

User ID: {user_id}
Agent ID: support_bot
Run ID: {session_id}

Buffer Limit: 10
Fallback to Search: true
Search Mode: balanced
Top K: 5
Max Context Characters: 500
Store Strategy: facts_only

Expected tokens per turn (after Turn 1): ~150

Configuration B: Balanced (Recommended)

Use case: General AI workflows, recommendations, Q&A

User ID: {user_id}
Agent ID: {agent_id}
Run ID: {conversation_id}

Buffer Limit: 20
Fallback to Search: true
Search Mode: balanced
Top K: 10
Max Context Characters: 700
Store Strategy: conversation

Expected tokens per turn (after Turn 1): ~250

Configuration C: Rich Context (High Quality)

Use case: Complex reasoning, multi-step workflows, research

User ID: {user_id}
Agent ID: {agent_id}
Run ID: {run_id}

Buffer Limit: 50
Fallback to Search: true
Search Mode: strict_facts
Top K: 20
Max Context Characters: 1500
Store Strategy: conversation
Include Assistant Memories: true

Expected tokens per turn (after Turn 1): ~600

Troubleshooting

❌ Problem: chat_history is empty

Check:

  1. User ID & Agent ID: Are they correct and consistent?

    ✓ "alice" + "support_bot" = OK
✗ "alice" + "support_bot2" = Different memory!

  2. Credentials: Test with:

    curl -X GET http://localhost:8000/health \
  -H "X-API-Key: your-key"

  3. Mem0 Server: Is it running and responding?

    • Check Mem0 logs
    • Test /memories endpoint directly

  4. Run ID: If set, ensure it matches previous session

Solution: Reset User ID and Agent ID, try again.

❌ Problem: Token usage is too high

Tuning steps:

  1. Lower Buffer Limit

    Before: bufferLimit = 50
After:  bufferLimit = 10
Effect: 80% token reduction

  2. Reduce Max Context

    Before: maxContextChars = 1500
After:  maxContextChars = 500
Effect: 67% token reduction

  3. Use Facts Only

    Before: storeStrategy = conversation
After:  storeStrategy = facts_only
Effect: 40% reduction in stored data

  4. Lower Top K

    Before: topK = 20
After:  topK = 5
Effect: 60% token reduction

Recommendation: Combine steps 1 + 2 for 85%+ reduction.

❌ Problem: Memory quality is poor (wrong context)

Debugging:

  1. Check Store Strategy

    If noisy: Set storeStrategy = facts_only
If incomplete: Set storeStrategy = conversation

  2. Enable Search Fallback

    fallbackToSearchOnBufferMiss = true
searchMode = strict_facts

  3. Increase Context Window

    Before: bufferLimit = 5
After:  bufferLimit = 20

  4. Filter Irrelevant Memories

    searchFilters: {
  "exclude_category": "debug",
  "priority": "high"
}

Recommendation: v0.2.13 sliding window ensures recent context is always fresh!

❌ Problem: Memory not persisting between runs

Check:

  1. Mem0 Database: Is persistence enabled?

    • Check Mem0 configuration
    • Ensure database is not in-memory only

  2. User ID / Agent ID: Must be identical across runs

    ✓ Same "alice" + "support_bot"
✗ "alice123" vs "alice" = Different memory!

  3. Storage: Verify messages are being saved:

    curl -X GET http://localhost:8000/memories \
  -H "X-API-Key: key" \
  -d '{"user_id":"alice","agent_id":"support_bot"}'

Safety & Security

Best Practices

✅ DO:

  • Store API keys only in n8n Credentials
  • Use stable, predictable IDs for user/agent
  • Set Run ID for session isolation
  • Validate user input before storing
  • Audit memory retrievals in production

❌ DON'T:

  • Hardcode API keys in workflows
  • Mix users' data (wrong ID values)
  • Store PII without encryption
  • Skip Run ID in multi-tenant workflows
  • Expose API keys in logs

Memory Isolation

┌─────────────────────────────────────────┐
│ User Memory Isolation (v0.2.13)          │
├─────────────────────────────────────────┤
│                                          │
│ Alice's Memory                           │
│ ├─ user_id = "alice"                   │
│ ├─ agent_id = "support_bot"            │
│ └─ run_id = "session_001" (optional)   │
│                                          │
│ Bob's Memory                             │
│ ├─ user_id = "bob"                     │
│ ├─ agent_id = "support_bot"            │
│ └─ run_id = "session_002" (optional)   │
│                                          │
│ ✓ Fully isolated (different user_ids)  │
│                                          │
└─────────────────────────────────────────┘

Version History

v0.2.13 (2026-04-17) - Current

��� Major Performance Release

  • Implemented sliding window memory optimization
  • 95% token reduction after 1st interaction
  • Cache per user+agent (global scope)
  • Optimized for production multi-turn conversations
  • TypeScript clean, fully tested

Changes:

  • Phase 1: Added tracking infrastructure
  • Phase 2: Implemented sliding window logic
  • Phase 3: Added cache invalidation
  • No breaking changes (transparent optimization)

Upgrade: Safe to upgrade immediately. No workflow changes needed.

v0.2.12 (2026-04-16)

  • Removed non-functional semantic_facts mode
  • Hardcoded conversation_pairs as default
  • Simplified memory retrieval logic

v0.2.11 (2026-04-15)

  • Fixed 3 critical bugs in message handling
  • Improved API response parsing

License

MIT

Contributing

This is a community-maintained package. Contributions welcome!

GitHub: https://github.com/kallbuloso/n8n-nodes-mem0-self
Issues: https://github.com/kallbuloso/n8n-nodes-mem0-self/issues

Disclaimer

⚠️ This package is independent and community-maintained.

  • NOT affiliated with Mem0 Inc.
  • NOT officially supported by Mem0
  • Use at your own risk
  • For self-hosted Mem0 OSS only
  • No commercial support

For Mem0 Cloud, use official Mem0 integrations.

Last Updated: April 17, 2026 | Version 0.2.13

Discussion