n8n-nodes-tembory 1.0.0

package/README.md

@@ -0,0 +1,75 @@
+# Tembory
+
+Node de memoria operacional da Tembory para agentes de IA no n8n.
+
+Versao atual: `1.0.0`.
+
+O Tembory entrega contexto rico para o AI Agent sem depender apenas do historico textual da conversa. Ele combina memoria semantica, working memory, decision state, fatos estaveis do lead, historico de tools, estado operacional, action ledger, timeline de entidades, compressao de memoria, grafo, mensagens recentes e diagnosticos.
+
+## Smoke tecnico
+
+Antes de publicar uma versao, rode:
+
+```bash
+npm run smoke:n8n:multiturn
+```
+
+O smoke simula 12 trocas com tools de agenda, valida tool history, working memory, decision state, memory compression e exige `contextHealth` com score minimo de `970/1000`.
+
+## Principais recursos
+
+- Porta `ai_memory` para conectar direto no AI Agent do n8n.
+- Campo `Projeto` para isolar memórias por cliente/workspace mesmo quando a origem repete o mesmo ID de conversa.
+- Entradas opcionais `ai_languageModel` e `ai_embedding` para usar os modelos conectados pelo cliente no proprio n8n.
+- Profile facts: nome, empresa, email, telefone, preferencias e contexto comercial.
+- Tool history: quais tools foram chamadas, quando, com qual status e resultado.
+- Tool guard: bloqueia acoes dependentes quando falta contexto previo.
+- Working memory: objetivo atual, intencao recente, entidades ativas, ultimo erro e proxima acao esperada.
+- Decision state: decisoes ativas, ferramentas que nao devem ser repetidas e politica de resolucao de conflitos.
+- Operational state: resumo deterministico do estado atual das tools e do proximo passo seguro.
+- Action ledger: linha cronologica das acoes executadas pelo agente.
+- Entity timeline: evolucao compacta de entidades, fatos, relacoes e eventos relevantes.
+- Memory compression: resumos de turno, sessao, entidades e workflow para reduzir ruido e aproximar o contexto do comportamento do ChatGPT/Codex.
+- Vector memories com scores, recent messages, highlights, graph e resumo.
+
+## Custo de IA
+
+O node nao fornece LLM nem embedding gerenciados pela Tembory. Todo uso de LLM e embedding deve vir dos nodes/modelos conectados no cluster do n8n do cliente. O backend do Tembory armazena e consulta os vetores recebidos prontos.
+
+## Presets operacionais
+
+O campo avancado `Preset Operacional` preenche defaults sem sobrescrever valores configurados manualmente:
+
+- `Custom`: comportamento manual.
+- `Diagnóstico Completo`: diagnostico completo para teste e auditoria.
+- `Producao Balanceada`: contexto rico com menos ruido.
+- `Producao Economica`: reduz secoes e resultados para economizar tokens.
+- `Auditoria`: payload detalhado para depuracao.
+
+## Blocos de contexto
+
+Quando habilitados, o agente recebe:
+
+- `Profile facts`
+- `Working memory`
+- `Decision state`
+- `Operational state`
+- `Action ledger`
+- `Entity timeline`
+- `Memory compression`
+- `Tool guard`
+- `Vector memories`
+- `Graph`
+- `Recent messages`
+- `Recent highlights`
+- `Tool history`
+- `Diagnostics`
+
+## Teste local
+
+```bash
+npm test
+npm pack --dry-run
+```
+
+Site: https://tembory.com

package/dist/credentials/Mem0Api.credentials.d.ts

@@ -0,0 +1,10 @@
+import { IAuthenticateGeneric, ICredentialTestRequest, ICredentialType, INodeProperties } from 'n8n-workflow';
+export declare class Mem0Api implements ICredentialType {
+    name: string;
+    displayName: string;
+    documentationUrl: string;
+    properties: INodeProperties[];
+    authenticate: IAuthenticateGeneric;
+    test: ICredentialTestRequest;
+}
+

package/dist/credentials/Mem0Api.credentials.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Mem0Api = void 0;
+class Mem0Api {
+    constructor() {
+        this.name = 'mem0Api';
+        this.displayName = 'Tembory Cloud API';
+        this.documentationUrl = 'https://tembory.com';
+        this.properties = [
+            {
+                displayName: 'API Key',
+                name: 'apiKey',
+                type: 'string',
+                typeOptions: { password: true },
+                default: '',
+                required: true,
+                description: 'API key for the managed Tembory memory backend.',
+            },
+            {
+                displayName: 'Organization ID',
+                name: 'orgId',
+                type: 'string',
+                default: '',
+                description: 'Optional: Organization ID',
+            },
+            {
+                displayName: 'Project ID',
+                name: 'projectId',
+                type: 'string',
+                default: '',
+                description: 'Optional: Project ID',
+            },
+        ];
+        this.authenticate = {
+            type: 'generic',
+            properties: {
+                headers: {
+                    'Authorization': '=Token {{$credentials.apiKey}}',
+                },
+            },
+        };
+        this.test = {
+            request: {
+                baseURL: 'https://api.mem0.ai',
+                url: '/v1/entities/',
+                method: 'GET',
+            },
+        };
+    }
+}
+exports.Mem0Api = Mem0Api;
+

package/dist/credentials/Mem0SelfHostedApi.credentials.d.ts

@@ -0,0 +1,10 @@
+import { IAuthenticateGeneric, ICredentialTestRequest, ICredentialType, INodeProperties } from 'n8n-workflow';
+export declare class Mem0SelfHostedApi implements ICredentialType {
+    name: string;
+    displayName: string;
+    documentationUrl: string;
+    properties: INodeProperties[];
+    authenticate: IAuthenticateGeneric;
+    test: ICredentialTestRequest;
+}
+

package/dist/credentials/Mem0SelfHostedApi.credentials.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Mem0SelfHostedApi = void 0;
+class Mem0SelfHostedApi {
+    constructor() {
+        this.name = 'mem0SelfHostedApi';
+        this.displayName = 'Tembory Self-Hosted API';
+        this.documentationUrl = 'https://tembory.com';
+        this.properties = [
+            {
+                displayName: 'Base URL',
+                name: 'baseUrl',
+                type: 'string',
+                default: 'http://localhost:8000',
+                required: true,
+                description: 'The base URL of your self-hosted Tembory memory backend',
+            },
+            {
+                displayName: 'API Key',
+                name: 'apiKey',
+                type: 'string',
+                typeOptions: { password: true },
+                default: '',
+                description: 'API key if authentication enabled',
+            },
+        ];
+        this.authenticate = {
+            type: 'generic',
+            properties: {
+                headers: {
+                    'Authorization': '={{$credentials.apiKey ? "Token " + $credentials.apiKey : ""}}',
+                },
+            },
+        };
+        this.test = {
+            request: {
+                baseURL: '={{$credentials.baseUrl}}',
+                url: '/v1/entities/',
+                method: 'GET',
+            },
+        };
+    }
+}
+exports.Mem0SelfHostedApi = Mem0SelfHostedApi;
+

package/dist/nodes/Mem0/GenericFunctions.d.ts

@@ -0,0 +1,3 @@
+import { IExecuteFunctions, ILoadOptionsFunctions, IHookFunctions, IWebhookFunctions, IHttpRequestMethods } from 'n8n-workflow';
+export declare function mem0ApiRequest(this: IExecuteFunctions | ILoadOptionsFunctions | IHookFunctions | IWebhookFunctions, method: IHttpRequestMethods, endpoint: string, body?: any, qs?: any): Promise<any>;
+

package/dist/nodes/Mem0/GenericFunctions.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mem0ApiRequest = mem0ApiRequest;
+const n8n_workflow_1 = require("n8n-workflow");
+async function mem0ApiRequest(method, endpoint, body = {}, qs = {}) {
+    // Support both Portuguese parameter name used in CRUD node and English used in Memory node
+    let authenticationType;
+    try {
+        authenticationType = this.getNodeParameter('tipoAutenticacao', 0);
+    }
+    catch (e) {
+        authenticationType = this.getNodeParameter('authType', 0) || 'nuvem';
+        // Map to legacy values used below
+        if (authenticationType === 'cloud')
+            authenticationType = 'nuvem';
+        if (authenticationType === 'selfHosted')
+            authenticationType = 'selfHosted';
+    }
+    let credentials;
+    let baseUrl;
+    if (authenticationType === 'nuvem') {
+        credentials = await this.getCredentials('mem0Api');
+        baseUrl = 'https://api.mem0.ai';
+    }
+    else {
+        credentials = await this.getCredentials('mem0SelfHostedApi');
+        baseUrl = credentials.baseUrl.replace(/\/$/, ''); // Remove trailing slash
+    }
+    const options = {
+        method,
+        body,
+        qs,
+        url: `${baseUrl}${endpoint}`,
+        json: true,
+    };
+    if (credentials.apiKey) {
+        options.headers = {
+            'Authorization': `Token ${credentials.apiKey}`,
+        };
+    }
+    try {
+        return await this.helpers.request(options);
+    }
+    catch (error) {
+        throw new n8n_workflow_1.NodeApiError(this.getNode(), error);
+    }
+}
+

package/dist/nodes/Mem0/Mem0Memory.node.d.ts

@@ -0,0 +1,15 @@
+import type { ISupplyDataFunctions, IExecuteFunctions, INodeType, INodeTypeDescription, INodeExecutionData } from 'n8n-workflow';
+export declare class Mem0Memory implements INodeType {
+    description: INodeTypeDescription;
+    supplyData(this: ISupplyDataFunctions, itemIndex: number): Promise<{
+        response: any;
+    }>;
+    saveContextForItem(this: ISupplyDataFunctions, itemIndex: number, inputValues?: Record<string, unknown>, outputValues?: Record<string, unknown>): Promise<void>;
+    loadMemoryVariablesForItem(this: ISupplyDataFunctions, itemIndex: number, inputValues?: Record<string, unknown>): Promise<{
+        response: {
+            [x: string]: unknown;
+        };
+    }>;
+    execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;
+}
+