n8n-nodes-tembory 1.0.43 → 1.0.45

package/dist/nodes/Mem0/Mem0Memory.node.js

@@ -632,6 +632,36 @@ const encodeToolLedger = (tools = [], threadId) => {
     })),
     })}`;
 };
+const encodeTurnArchive = ({ threadId, messages = [], tools = [], workingMemory = {}, decisionState = {}, memoryCompression = {}, operationalState = {} }) => {
+    const chronological = sortConversationChronological(messages || []);
+    const orderedTools = sortToolHistory(tools || []);
+    return `Tembory long-term turn archive. Use vector search only when short-term SLM state and recent transcript are insufficient. ${safeStringify({
+        marker: 'tembory_turn_archive_v1',
+        thread_id: threadId,
+        generated_at: nowIso(),
+        conversation: chronological.map((msg) => ({
+            role: msg.role || 'user',
+            content: msg.content || '',
+            at: msg.at || nowIso(),
+        })),
+        tools: orderedTools.map((tool, index) => ({
+            id: tool.id || tool.callId || tool.call_id || '',
+            turn_id: tool.turnId || tool.turn_id || '',
+            sequence: tool.sequence || index + 1,
+            name: tool.name || tool.tool || tool.toolName || '',
+            reason: tool.reason || tool.source || '',
+            input: tool.input || '',
+            ok: tool.ok !== false,
+            output: tool.result || '',
+            at: tool.at || nowIso(),
+            source: tool.source || 'n8n',
+        })),
+        working_memory: workingMemory,
+        decision_state: decisionState,
+        memory_compression: memoryCompression,
+        operational_state: operationalState,
+    })}`;
+};
 const parseRecentMessageMarker = (text) => {
     if (!text || typeof text !== 'string' || !text.startsWith(RECENT_MESSAGE_MARKER))
         return null;
@@ -720,6 +750,23 @@ const parseConversationLedgerMarker = (text) => {
         return [];
     }
 };
+const parseTurnArchive = (text) => {
+    if (!text || typeof text !== 'string')
+        return null;
+    const marker = '"marker":"tembory_turn_archive_v1"';
+    const markerIndex = text.indexOf(marker);
+    if (markerIndex < 0)
+        return null;
+    const jsonStart = text.lastIndexOf('{', markerIndex);
+    if (jsonStart < 0)
+        return null;
+    try {
+        return JSON.parse(text.slice(jsonStart));
+    }
+    catch {
+        return null;
+    }
+};
 const recentMessageFromMemory = (item) => {
     const meta = metadataOf(item);
     const content = meta.content || item.memory || item.text || item.value || item.content || item.data;
@@ -739,6 +786,16 @@ const recentMessageFromMemory = (item) => {
 const recentMessagesFromMemory = (item) => {
     const meta = metadataOf(item);
     const content = meta.content || item.memory || item.text || item.value || item.content || item.data;
+    const archive = parseTurnArchive(content);
+    if (archive && Array.isArray(archive.conversation)) {
+        return archive.conversation
+            .filter((msg) => msg && msg.content)
+            .map((msg) => ({
+            role: msg.role || 'user',
+            content: truncate(msg.content, 2000),
+            at: msg.at || archive.generated_at || nowIso(),
+        }));
+    }
     const ledger = parseConversationLedgerMarker(content);
     if (ledger.length)
         return ledger;
@@ -803,6 +860,22 @@ const toolHistoryFromMemory = (item) => {
 const explicitToolHistoryItemsFromMemory = (item) => {
     const meta = metadataOf(item);
     const content = meta.content || item.memory || item.text || item.value || item.content || item.data;
+    const archive = parseTurnArchive(content);
+    if (archive && Array.isArray(archive.tools)) {
+        return archive.tools
+            .filter((tool) => tool && tool.name)
+            .map((tool, index) => ({
+            id: tool.id || tool.call_id || tool.callId || '',
+            turnId: tool.turn_id || tool.turnId || '',
+            sequence: tool.sequence || index + 1,
+            name: String(tool.name),
+            input: tool.input === undefined ? '' : String(tool.input),
+            ok: tool.ok !== false,
+            result: truncate(tool.output || tool.result || '', 1000),
+            at: tool.at || archive.generated_at || nowIso(),
+            source: tool.source || 'turn_archive',
+        }));
+    }
     const ledger = parseToolLedgerMarker(content);
     if (ledger.length)
         return ledger;
@@ -1125,7 +1198,7 @@ const applyOperationalPreset = (advanced = {}) => {
             enableTransientSummaryCache: true,
             transientSummaryCacheTTLSeconds: 300,
             compactStateSections: true,
-            useVectorMemory: true,
+            useVectorMemory: false,
             persistBackendMemories: true,
             includeRecentMessageProbe: false,
             includeToolLedgerProbe: false,
@@ -2598,7 +2671,7 @@ class Mem0Memory {
                                 { displayName: 'Máximo de Relações', name: 'maxRelations', type: 'number', default: 10 },
                                 { displayName: 'Incluir Action Ledger', name: 'includeActionLedger', type: 'boolean', default: true },
                                 { displayName: 'Incluir Entity Timeline', name: 'includeEntityTimeline', type: 'boolean', default: false },
-                                { displayName: 'Usar Memória Vetorial no Caminho Quente', name: 'useVectorMemory', type: 'boolean', default: true },
+                                { displayName: 'Usar Memória Vetorial no Caminho Quente', name: 'useVectorMemory', type: 'boolean', default: false },
                                 { displayName: 'Persistir Memórias no Backend', name: 'persistBackendMemories', type: 'boolean', default: true },
                                 { displayName: 'Probe Vetorial de Mensagens Recentes', name: 'includeRecentMessageProbe', type: 'boolean', default: false },
                                 { displayName: 'Probe Vetorial de Tool Ledger', name: 'includeToolLedgerProbe', type: 'boolean', default: false },
@@ -2695,7 +2768,7 @@ class Mem0Memory {
                         { displayName: 'App ID', name: 'appId', type: 'string', default: '' },
                         { displayName: 'Run ID', name: 'runId', type: 'string', default: '' },
                         { displayName: 'Top K', name: 'topK', type: 'number', typeOptions: { minValue: 1 }, default: 25, description: 'Quantidade de memórias a recuperar (modos semânticos e limites de recentes)' },
-                        { displayName: 'Usar Memória Vetorial no Caminho Quente', name: 'useVectorMemory', type: 'boolean', default: true, description: 'Quando ligado, usa uma busca BYO mínima para recuperar memórias persistidas; probes/grafo continuam separados.' },
+                        { displayName: 'Usar Memória Vetorial no Caminho Quente', name: 'useVectorMemory', type: 'boolean', default: false, description: 'Quando ligado, usa busca BYO sob demanda para recuperar histórico longo. O padrão mantém o contexto quente em transcript + SLM e apenas arquiva o turno no vetor.' },
                         { displayName: 'Persistir Memórias no Backend', name: 'persistBackendMemories', type: 'boolean', default: true, description: 'Quando desligado, mantém o estado no workflow/static data para reduzir latência.' },
                         { displayName: 'Rerank', name: 'rerank', type: 'boolean', default: true, description: 'Reordenação por relevância (modos semânticos)', displayOptions: { show: { '/retrievalMode': ['semantic', 'semanticV2', 'hybrid'] } } },
                         { displayName: 'Fields (lista separada por vírgula)', name: 'fields', type: 'string', default: '', description: 'Campos específicos a retornar da API (modos semânticos)', displayOptions: { show: { '/retrievalMode': ['semantic', 'semanticV2', 'hybrid'] } } },
@@ -3009,69 +3082,27 @@ class Mem0Memory {
         const connectedEmbedding = await getConnectedEmbedding(this, itemIndex);
         if (connectedEmbedding) {
             const ids = { user_id: body.user_id, agent_id: body.agent_id, run_id: body.run_id };
-            const clientMemories = [];
-            for (const message of messages) {
-                clientMemories.push(await createClientVectorMemory(connectedEmbedding, message.content, {
-                    kind: 'conversation_message',
-                    role: message.role,
-                    thread_id: threadId,
-                    project: project || undefined,
-                    at: nowIso(),
-                    source: 'n8n_connected_embedding',
-                }, ids));
-            }
-            if (adv.includeRecentMessages !== false && recentForMem0.length) {
-                for (const recent of recentForMem0) {
-                    clientMemories.push(await createClientVectorMemory(connectedEmbedding, encodeRecentMessage(recent, threadId), {
-                        kind: 'recent_message',
-                        role: recent.role,
-                        content: recent.content,
-                        at: recent.at,
-                        thread_id: threadId,
-                        project: project || undefined,
-                        source: 'n8n_connected_embedding',
-                    }, ids));
-                }
-                clientMemories.push(await createClientVectorMemory(connectedEmbedding, encodeConversationLedger(recentForTurn, threadId), {
-                    kind: 'conversation_ledger',
-                    thread_id: threadId,
-                    project: project || undefined,
-                    source: 'n8n_connected_embedding',
-                    generated_at: nowIso(),
-                }, ids));
-            }
-            if (adv.persistToolFactsToMem0 && toolCalls.length) {
-                const facts = toolCalls.map((tool) => `Tool ${tool.name} input=${tool.input}${tool.result ? ` result=${tool.result}` : ''}`).join('\n');
-                clientMemories.push(await createClientVectorMemory(connectedEmbedding, `Tool facts (read-only):\n${truncate(facts, 2000)}`, {
-                    kind: 'tool_facts',
-                    source: 'n8n_connected_embedding',
-                }, ids));
-            }
-            if (adv.includeToolHistory !== false && toolCalls.length) {
-                for (const tool of toolCalls) {
-                    clientMemories.push(await createClientVectorMemory(connectedEmbedding, encodeToolCall(tool, threadId), {
-                        kind: 'tool_history',
-                        id: tool.id,
-                        sequence: tool.sequence,
-                        turn_id: tool.turnId,
-                        name: tool.name,
-                        input: tool.input,
-                        ok: tool.ok,
-                        result: tool.result,
-                        at: tool.at,
-                        source: tool.source || 'n8n_connected_embedding',
-                        thread_id: threadId,
-                    }, ids));
-                }
-                clientMemories.push(await createClientVectorMemory(connectedEmbedding, encodeToolLedger(toolHistoryForTurn, threadId), {
-                    kind: 'tool_ledger',
+            const archiveText = encodeTurnArchive({
+                threadId,
+                messages: recentForTurn,
+                tools: toolHistoryForTurn,
+                workingMemory: workingMemoryForTurn,
+                decisionState: decisionStateForTurn,
+                memoryCompression: compressionForTurn,
+                operationalState: operationalStateForTurn,
+            });
+            await saveClientVectorMemories(this, [
+                await createClientVectorMemory(connectedEmbedding, archiveText, {
+                    kind: 'turn_archive',
                     thread_id: threadId,
                     project: project || undefined,
                     source: 'n8n_connected_embedding',
                     generated_at: nowIso(),
-                }, ids));
-            }
-            await saveClientVectorMemories(this, clientMemories, ids);
+                    message_count: recentForTurn.length,
+                    tool_count: toolHistoryForTurn.length,
+                    latest_tool: toolHistoryForTurn.at(-1)?.name || null,
+                }, ids),
+            ], ids);
             if (adv.includeRecentMessages !== false && recentForMem0.length) {
                 for (const recent of recentForMem0) {
                     await safePersistLegacyMemory(this, {
@@ -3296,7 +3327,7 @@ class Mem0Memory {
         catch (error) {
             connectedAi.errors.push(`languageModel: ${error.message || String(error)}`);
         }
-        if (vectorMemoryEnabled) {
+        if (vectorMemoryEnabled || backendPersistenceEnabled) {
             try {
                 connectedEmbedding = await this.getInputConnectionData(n8n_workflow_1.NodeConnectionTypes.AiEmbedding, itemIndex);
                 connectedAi.embedding = true;
@@ -3305,15 +3336,8 @@ class Mem0Memory {
                 connectedAi.errors.push(`embedding: ${error.message || String(error)}`);
             }
         }
-        if (connectedEmbedding && typeof connectedEmbedding.embedQuery === 'function' && String(query || '').trim()) {
-            try {
-                await embedQueryCached(connectedEmbedding, String(query));
-                connectedAi.embeddingQuery = true;
-            }
-            catch (error) {
-                connectedAi.errors.push(`embedding.embedQuery: ${error.message || String(error)}`);
-            }
-        }
+        if (connectedEmbedding && typeof connectedEmbedding.embedQuery === 'function' && String(query || '').trim())
+            connectedAi.embeddingQuery = vectorMemoryEnabled;
         try {
             this.logger?.debug('Tembory loading memory variables before model invocation', {
                 itemIndex,
@@ -3325,6 +3349,28 @@ class Mem0Memory {
         catch { }
         let payload;
         let vectorMemories = [];
+        if (!vectorMemoryEnabled && backendPersistenceEnabled && connectedEmbedding && String(query || '').trim()) {
+            try {
+                const archiveBody = {
+                    user_id: key,
+                    agent_id: adv.agentId ? String(adv.agentId) : undefined,
+                    run_id: adv.runId ? String(adv.runId) : undefined,
+                    top_k: Math.max(Number(adv.lastN || 0), Number(adv.maxReturn || 12), 12),
+                    filters: { kind: 'turn_archive' },
+                };
+                const archiveRes = await searchClientVectorMemories(this, connectedEmbedding, `latest turn archive for thread ${threadId}\n${query}`, archiveBody);
+                vectorMemories = normalizeResults(archiveRes).map((memory) => withTemboryScore(memory, {
+                    semanticScore: scoreOf(memory),
+                    source: 'turn_archive_lookup',
+                }));
+                connectedAi.embedding = true;
+                connectedAi.embeddingQuery = true;
+                connectedAi.turnArchiveLookup = true;
+            }
+            catch (error) {
+                connectedAi.errors.push(`turnArchiveLookup: ${error.message || String(error)}`);
+            }
+        }
         if (vectorMemoryEnabled && (retrievalMode === 'semantic' || retrievalMode === 'semanticV2' || retrievalMode === 'hybrid')) {
             const body = { query: String(query || '') };
             // IDs

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "n8n-nodes-tembory",
-  "version": "1.0.43",
+  "version": "1.0.45",
   "description": "Tembory node for n8n AI Agents with profile, tools, timeline, graph and semantic memory",
   "license": "MIT",
   "homepage": "https://tembory.com",