n8n Workflow Nodes

Copy{
  "name": "@mem0/n8n-nodes-mem0",
  "version": "0.1.4",
  "engines": {
    "node": ">=20.15"
  },
  "n8n": {
    "n8nNodesApiVersion": 1,
    "credentials": [
      "dist/credentials/Mem0Api.credentials.js"
    ],
    "nodes": [
      "dist/nodes/Mem0/Mem0.node.js"
    ]
  }
}

Copy// n8n loads nodes and credentials via the "n8n" key in package.json.
// This entry point is intentionally empty.
module.exports = {};

Copydescription: INodeTypeDescription = {
	displayName: 'Mem0',
	name: 'mem0',
	icon: { light: 'file:mem0.svg', dark: 'file:mem0.svg' },
	group: ['transform'],
	version: 1,
	subtitle: '={{$parameter["operation"] + ": " + $parameter["resource"]}}',
	description: 'Add, search, and manage long-term memories with Mem0',
	defaults: {
		name: 'Mem0',
	},
	// Makes the node available to the AI Agent (Tools Agent) node.
	usableAsTool: true,
	inputs: [NodeConnectionTypes.Main],
	outputs: [NodeConnectionTypes.Main],
	credentials: [
		{
			name: 'mem0Api',
			required: true,
		},
	],

Copy{
	displayName: 'Resource',
	name: 'resource',
	type: 'options',
	noDataExpression: true,
	options: [{ name: 'Memory', value: 'memory' }],
	default: 'memory',
},
{
	displayName: 'Operation',
	name: 'operation',
	type: 'options',
	noDataExpression: true,
	displayOptions: { show: { resource: ['memory'] } },
	options: [
		{
			name: 'Add',
			value: 'add',
			action: 'Add a memory',
			description: 'Extract and store memories from messages',
		},
		{
			name: 'Delete',
			value: 'delete',
			action: 'Delete a memory',
			description: 'Delete a single memory by ID',
		},
		{
			name: 'Get',
			value: 'get',
			action: 'Get a memory',
			description: 'Retrieve a single memory by ID',
		},
		{
			name: 'Get Many',
			value: 'getAll',
			action: 'Get many memories',
			description: 'List stored memories for an entity',
		},
		{
			name: 'Search',
			value: 'search',
			action: 'Search memories',
			description: 'Semantic search over stored memories',
		},
		{
			name: 'Update',
			value: 'update',
			action: 'Update a memory',
			description: 'Update the text or metadata of a memory',
		},
	],
	default: 'add',
},

Copy{
	displayName: 'Messages',
	name: 'messages',
	placeholder: 'Add Message',
	type: 'fixedCollection',
	typeOptions: { multipleValues: true },
	displayOptions: { show: { resource: ['memory'], operation: ['add'] } },
	default: {},
	description: 'The conversation messages to extract memories from',
	options: [
		{
			name: 'message',
			displayName: 'Message',
			values: [
				{
					displayName: 'Role',
					name: 'role',
					type: 'options',
					options: [
						{ name: 'User', value: 'user' },
						{ name: 'Assistant', value: 'assistant' },
						{ name: 'System', value: 'system' },
					],
					default: 'user',
				},
				{
					displayName: 'Content',
					name: 'content',
					type: 'string',
					typeOptions: { rows: 2 },
					default: '',
				},
			],
		},
	],
},
{
	displayName: 'User ID',
	name: 'userId',
	type: 'string',
	default: '',
	displayOptions: { show: { resource: ['memory'], operation: ['add'] } },
	description: 'Associate the memories with this user',
},
{
	displayName: 'Wait for Completion',
	name: 'waitForCompletion',
	type: 'boolean',
	default: true,
	displayOptions: { show: { resource: ['memory'], operation: ['add'] } },
	description:
		'Whether to poll until memory extraction finishes and return the resulting memories. Turn off to return immediately with the event ID.',
},
{
	displayName: 'Additional Fields',
	name: 'addFields',
	type: 'collection',
	placeholder: 'Add Field',
	default: {},
	displayOptions: { show: { resource: ['memory'], operation: ['add'] } },
	options: [
		{
			displayName: 'Agent ID',
			name: 'agent_id',
			type: 'string',
			default: '',
		},
		{
			displayName: 'App ID',
			name: 'app_id',
			type: 'string',
			default: '',
		},
		{
			displayName: 'Custom Categories',
			name: 'custom_categories',
			type: 'json',
			default: '',
			description:
				'Optional taxonomy for categorising extracted memories, as a JSON array of {category: description} objects',

Copy	{
		displayName: 'Page',
		name: 'page',
		type: 'number',
		typeOptions: { minValue: 1 },
		default: 1,
		displayOptions: {
			show: { resource: ['memory'], operation: ['getAll'], returnAll: [false] },
		},
	},
	{
		displayName: 'Page Size',
		name: 'pageSize',
		type: 'number',
		typeOptions: { minValue: 1 },
		default: 50,
		displayOptions: { show: { resource: ['memory'], operation: ['getAll'] } },
	},
 
	// ---- Get / Update / Delete (by ID) -------------------------------
	{
		displayName: 'Memory ID',
		name: 'memoryId',
		type: 'string',
		default: '',
		required: true,
		displayOptions: {
			show: { resource: ['memory'], operation: ['get', 'update', 'delete'] },
		},
	},
	{
		displayName: 'Text',
		name: 'text',
		type: 'string',
		default: '',
		displayOptions: { show: { resource: ['memory'], operation: ['update'] } },
		description: 'The new memory text',
	},
	{
		displayName: 'Metadata (JSON)',
		name: 'metadata',
		type: 'json',
		default: '',
		displayOptions: { show: { resource: ['memory'], operation: ['update'] } },
	},
],

Copyasync execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]> {
	const items = this.getInputData();
	const returnData: INodeExecutionData[] = [];
	const credentials = await this.getCredentials('mem0Api');
	const baseUrl = (credentials.baseUrl as string) || 'https://api.mem0.ai';
 
	const request = async (
		method: IHttpRequestMethods,
		url: string,
		body?: IDataObject,
		qs?: IDataObject,
	): Promise<IDataObject> => {
		const options: IHttpRequestOptions = {
			method,
			url: `${baseUrl}${url}`,
			json: true,
			...(body ? { body } : {}),
			// First-party usage attribution: the backend reads `source` (same as OpenClaw).
			qs: { source: 'N8N', ...(qs ?? {}) },
		};
		return (await this.helpers.httpRequestWithAuthentication.call(
			this,
			'mem0Api',
			options,
		)) as IDataObject;
	};

Copyfor (let i = 0; i < items.length; i++) {
	try {
		const operation = this.getNodeParameter('operation', i) as string;
		let responseData: IDataObject | IDataObject[] = {};
 
		if (operation === 'add') {
			const messagesUi = this.getNodeParameter('messages.message', i, []) as IDataObject[];
			if (!messagesUi.length) {
				throw new NodeOperationError(this.getNode(), 'At least one message is required', {
					itemIndex: i,
				});
			}

Copyconst addFields = this.getNodeParameter('addFields', i, {}) as IDataObject;
const body: IDataObject = {
	messages: messagesUi.map((m) => ({ role: m.role, content: m.content })),
	infer: addFields.infer !== undefined ? addFields.infer : true,
};
const userId = this.getNodeParameter('userId', i, '') as string;
if (userId) body.user_id = userId;

Copyconst userId = this.getNodeParameter('userId', i, '') as string;
if (userId) body.user_id = userId;

Copyconst credentials = await this.getCredentials('mem0Api');
const baseUrl = (credentials.baseUrl as string) || 'https://api.mem0.ai';
 
const request = async (
	method: IHttpRequestMethods,
	url: string,
	body?: IDataObject,
	qs?: IDataObject,
): Promise<IDataObject> => {
	const options: IHttpRequestOptions = {
		method,
		url: `${baseUrl}${url}`,
		json: true,
		...(body ? { body } : {}),
		// First-party usage attribution: the backend reads `source` (same as OpenClaw).
		qs: { source: 'N8N', ...(qs ?? {}) },
	};
	return (await this.helpers.httpRequestWithAuthentication.call(
		this,
		'mem0Api',
		options,
	)) as IDataObject;
};

Copy// Poll settings for asynchronous (infer=true) memory addition.
const POLL_INTERVAL_MS = 1500;
const MAX_POLL_ATTEMPTS = 40; // ~60s ceiling
 

Copyconst pollEvent = async (z: ZObject, eventId: string): Promise<EventResponse> => {
	for (let attempt = 0; attempt < MAX_POLL_ATTEMPTS; attempt++) {
		const res = await z.request({ url: `/v1/event/${eventId}/`, method: 'GET' });
		const data = res.data as EventResponse;
		const status = data && data.status;
		if (status === 'SUCCEEDED') {
			return data;
		}
		if (status === 'FAILED') {
			const reason = (data && (data.error || data.message)) || 'unknown error';
			throw new z.errors.Error(`Mem0 memory event ${eventId} failed: ${reason}`, 'Mem0EventFailed', 400);
		}
		await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
	}
	throw new z.errors.Error(
		`Timed out waiting for memory event ${eventId}. The add was accepted and is ` +
			`likely still completing on the server — a timeout here does not mean it failed.`,
		'Mem0Timeout',
		408,
	);
};