n8n-nodes-tembory 1.0.43 → 1.0.44

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;
@@ -1125,7 +1155,7 @@ const applyOperationalPreset = (advanced = {}) => {
             enableTransientSummaryCache: true,
             transientSummaryCacheTTLSeconds: 300,
             compactStateSections: true,
-            useVectorMemory: true,
+            useVectorMemory: false,
             persistBackendMemories: true,
             includeRecentMessageProbe: false,
             includeToolLedgerProbe: false,
@@ -2598,7 +2628,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 +2725,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 +3039,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, {
@@ -3305,15 +3293,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,

package/package.json

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