n8n

Prerequisites

• n8n instance (Cloud or self-hosted) at version 1.50 or above
• knowmind account on Business API or Enterprise (for personal API tokens)
• API token with scope write for Store and Link; scope read alone is enough for Recall and Stats

Steps

1. 1

   Path A: HTTP Request node against the MCP API (recommended)

   The simplest and most stable path. You call the knowmind MCP API over JSON-RPC 2.0, no node installation required. First create an HTTP Header Auth credential:

   textcopy

   Credentials → New → HTTP Header Auth
   Name:           knowmind Bearer
   Header Name:    Authorization
   Header Value:   Bearer kmt_…

   Then an HTTP Request node with this configuration:

   textcopy

   Method:         POST
   URL:            https://knowmind.de/api/mcp/v1
   Authentication: Generic Credential Type
   Generic Auth:   HTTP Header Auth (knowmind Bearer)
   Send Body:      yes, Body Content Type: JSON
   JSON Body:
   {
     "jsonrpc": "2.0",
     "id": 1,
     "method": "tools/call",
     "params": {
       "name": "knowmind.recall",
       "arguments": { "query": "{{ $json.subject }}", "k": 5 }
     }
   }

   Outcome: The node returns a JSON-RPC response. Hits sit under result.content[0].text as JSON text. Add a parse node downstream to get the list of memories.

2. 2

   Example workflow: store a memory on every new email

   A typical use case — every inbound email is stored as a memory in the Memory Store:

   textcopy

   1. IMAP Email Trigger (n8n)
      → catches new emails
   2. HTTP Request (POST https://knowmind.de/api/mcp/v1)
      Body:
      {
        "jsonrpc": "2.0",
        "id": 1,
        "method": "tools/call",
        "params": {
          "name": "knowmind.store_memory",
          "arguments": {
            "memory_type": "episodic",
            "title": "Mail from {{ $json.from }}",
            "content": "{{ $json.subject }}\n\n{{ $json.text }}",
            "source": "imap",
            "tags": ["mail", "{{ $json.from.replace('@', '-at-') }}"]
          }
        }
      }
   3. Set node: save the returned memory_id for downstream steps

   Outcome: Every email lands as a typed memory in the Memory Store and is recallable later.

3. 3

   Path B: Webhook node as a knowmind receiver

   When n8n should react to events from knowmind (memory created, plan changed), drop in a webhook trigger and register its URL in your workspace's Webhooks panel.

   textcopy

   1. Create a webhook trigger in n8n
      HTTP Method:   POST
      Path:          /knowmind-events
      Authentication: None (HMAC verification happens inside the workflow)
   
   2. In the knowmind dashboard, under "Webhooks":
      URL:    https://n8n.example.com/webhook/knowmind-events
      Events: memory.created, memory.updated, link.created
      Secret: copy from the dashboard, use it for HMAC verification
   
   3. Function node in the workflow for HMAC verification:
      const crypto = require('crypto');
      const sig = $headers['x-knowmind-signature'];
      const computed = crypto
        .createHmac('sha256', $vars.KNOWMIND_WEBHOOK_SECRET)
        .update(JSON.stringify($json))
        .digest('hex');
      if (sig !== computed) throw new Error('Invalid signature');
      return [{ json: $json }];

   Outcome: knowmind sends a POST request to your workflow on every configured event. The payload contains event type, memory ID and timestamps — full memory content is not sent (see data-flow path E).

4. 4

   Path C: Code node with the knowmind npm package (experimental)

   On a self-hosted n8n with external npm modules allowed, the knowmind CLI package can act as a Code-node library. Recommended only if you already work with Code nodes.

   javascriptcopy

   // n8n Code Node — JavaScript, mode: Run Once for All Items
   // Required: NODE_FUNCTION_ALLOW_EXTERNAL=knowmind in the n8n environment
   const { KnowmindClient } = require('knowmind');
   
   const client = new KnowmindClient({
     baseUrl: 'https://knowmind.de',
     token: $vars.KNOWMIND_TOKEN,
   });
   
   const hits = await client.recall({
     query: $input.first().json.subject,
     k: 5,
     hops: 2,
   });
   
   return hits.results.map((hit) => ({ json: hit }));

   Outcome: The package abstracts JSON-RPC calls and PKCE handling. Updates flow in through npm update knowmind in the n8n container.

5. 5

   Plan for rate limits and retries

   Workflows that call knowmind in loops (for example a bulk import of historical emails) hit the rate limit quickly: 60 requests per minute on Business API, 600 on Enterprise. The HTTP Request node has a built-in retry under Retry On Fail — enable it with Max Tries: 3 and Wait Between Tries: 2000 ms. knowmind responds with Retry-After on HTTP 429.

Verify the result

Troubleshooting

Roadmap: official community node

An official n8n-nodes-knowmind community node is in preparation. Planned operations: Recall, Store, Link, Unlink, List Relations, Stats, Health. Once it ships, the recommendation on this page moves from path A to the community node and the guide will be updated. As of 2026-05-23: in planning, no fixed release date.