Cross-Platform Continuity

Your AI assistant should remember context whether you are in Claude Desktop, Cursor, a browser, or a custom tool. This guide shows how to use MCP, the SDK, and the browser extension together for seamless memory across every platform.

Overview

Rekall provides three integration surfaces that all share the same memory backend:

  • •MCP Server -- 40+ tools for Claude Desktop, Claude Code, Cursor, and other MCP hosts
  • •SDKs -- TypeScript, Python, and Go SDKs for custom integrations
  • •Browser Extension -- Chrome extension for capturing web context into memory

All three surfaces read and write to the same memory. A conversation in Claude Desktop can reference a code review done in Cursor, or a research session captured by the browser extension.

Architecture

Cross-platform architecture
┌──────────────┐  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐
│ Claude       │  │ Cursor       │  │ Browser      │  │ Custom App   │
│ Desktop      │  │ IDE          │  │ Extension    │  │ (SDK)        │
└──────┬───────┘  └──────┬───────┘  └──────┬───────┘  └──────┬───────┘
       │                 │                 │                 │
       │  MCP Protocol   │  MCP Protocol   │  REST API       │  SDK
       │                 │                 │                 │
       ▼                 ▼                 ▼                 ▼
┌─────────────────────────────────────────────────────────────────────┐
│                     Rekall Memory Backend                          │
│                                                                     │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌──────────┐           │
│  │ Episodic │  │ Semantic │  │Procedural│  │ Execution│  ...       │
│  └──────────┘  └──────────┘  └──────────┘  └──────────┘           │
└─────────────────────────────────────────────────────────────────────┘

MCP + SDK + Browser Extension

MCP Server Setup

The Rekall MCP server exposes memory operations as tools that any MCP-compatible host can use. Install and configure it for your platforms.

MCP server configuration
// ~/Library/Application Support/Claude/claude_desktop_config.json
{
  "mcpServers": {
    "rekall": {
      "command": "npx",
      "args": ["-y", "@rekall/mcp-server"],
      "env": {
        "REKALL_API_KEY": "rk_your_key"
      }
    }
  }
}

SDK Integration

For custom applications, use the SDK directly. All SDK operations go through the same API, so memories are instantly available across all platforms.

SDK setup for cross-platform
import Rekall from '@rekall/agent-sdk';


// Initialize with platform context
const rekall = new Rekall({
  apiKey: 'rk_your_key',
  context: {
    platform: 'custom-app',
    sessionId: generateSessionId(),
  },
});


// Memories created here are searchable from Claude Desktop,
// Cursor, browser extension, and any other connected platform
await rekall.memories.create({
  type: 'episodic',
  content: 'Researched Neon database branching for the CI/CD pipeline',
  metadata: {
    tags: ['research', 'neon', 'ci-cd'],
    source: 'custom-app',
  },
});

Browser Extension

The Rekall browser extension captures web browsing context -- pages visited, notes taken, research sessions -- and stores them as memories.

Browser extension features
// The browser extension automatically:
// 1. Captures page context when you highlight text
// 2. Creates episodic memories from research sessions
// 3. Extracts entities from web pages into semantic memory
// 4. Syncs with all other Rekall-connected tools


// Example: You read a blog post about database optimization
// The extension creates:
{
  type: 'episodic',
  content: 'Read article: "10 PostgreSQL Performance Tips" - key takeaways: connection pooling, index optimization, VACUUM scheduling',
  metadata: {
    source: 'browser-extension',
    url: 'https://example.com/postgres-tips',
    tags: ['research', 'postgresql', 'performance'],
  },
  context: {
    platform: 'chrome-extension',
    sessionId: 'browse_abc123',
  },
}


// Later in Claude Desktop:
// "What did I read about PostgreSQL performance?"
// -> Finds the browser extension memory and provides context

Install the extension

Download the Rekall browser extension from the Downloads page. After installing, sign in with your Rekall account and it will automatically start syncing with your other platforms.

Syncing Memory Across Tools

Automatic Sync

All platforms connect to the same Rekall backend, so sync is automatic. When you create a memory in Cursor, it is instantly searchable from Claude Desktop. There is no manual sync step.

Cross-platform search
// From any platform, search across all sources
const results = await rekall.memories.search({
  query: 'database optimization research',
  // Results include memories from ALL platforms
});


for (const memory of results.memories) {
  console.log(`[${memory.context.platform}] ${memory.content}`);
}
// [chrome-extension] Read article: "10 PostgreSQL Performance Tips"...
// [cursor] Implemented connection pooling in payments-service
// [claude-desktop] Discussed VACUUM scheduling with the team
// [custom-app] Researched Neon database branching for CI/CD


// Filter by platform if needed
const cursorOnly = await rekall.memories.search({
  query: 'database optimization',
  filters: {
    context: { platform: 'cursor' },
  },
});

Conflict Resolution

Since all platforms write to the same backend, conflicts are rare. When they occur (e.g., two platforms update the same entity simultaneously), Rekall uses last-write-wins with version tracking.

Version tracking for entities
// Entities have version numbers
const entity = await rekall.semantic.getEntity({ entityId: 'ent_abc' });
console.log(`Version: ${entity.version}`); // 3


// Optimistic concurrency: specify expected version
try {
  await rekall.semantic.updateEntity({
    entityId: 'ent_abc',
    expectedVersion: 3,  // Fails if someone else updated it
    properties: { status: 'deprecated' },
  });
} catch (err) {
  if (err.code === 'VERSION_CONFLICT') {
    // Re-fetch and retry
    const fresh = await rekall.semantic.getEntity({ entityId: 'ent_abc' });
    // ... merge changes and retry
  }
}

Unified Context Across Platforms

Here is how to set up each platform for a seamless cross-platform experience.

Claude Desktop

With MCP configured, Claude Desktop has access to all 40+ Rekall tools. It can search memories, create new ones, query knowledge graphs, and manage workflows.

Example Claude Desktop interaction
User: "What was I working on yesterday in Cursor?"


Claude (using Rekall MCP tools):
- Calls rekall_search with query "work activity" and time filter for yesterday
- Finds memories from Cursor platform:
  1. "Refactored the auth module to use JWT tokens"
  2. "Fixed race condition in payment processing"
  3. "Added unit tests for the new validation layer"


Claude: "Yesterday in Cursor you worked on three main things:
1. Refactored the auth module to use JWT tokens
2. Fixed a race condition in payment processing
3. Added unit tests for the validation layer


The auth refactoring was the highest-importance task based on your memory data.
Would you like to continue with any of these?"

Cursor

Cursor with Rekall MCP provides code-aware memory. It remembers debugging sessions, file changes, and project context.

Cursor MCP configuration with context
{
  "mcpServers": {
    "rekall": {
      "command": "npx",
      "args": ["-y", "@rekall/mcp-server"],
      "env": {
        "REKALL_API_KEY": "rk_your_key",
        "REKALL_PLATFORM": "cursor",
        "REKALL_AUTO_CONTEXT": "true"
      }
    }
  }
}

Browser

The browser extension works passively in the background. Configure what it captures:

Browser extension settings
{
  "autoCapture": {
    "enabled": true,
    "captureHighlights": true,
    "captureBookmarks": true,
    "capturePageSummaries": false
  },
  "domains": {
    "allowlist": [],
    "blocklist": ["mail.google.com", "facebook.com"]
  },
  "tagging": {
    "autoTag": true,
    "defaultTags": ["research", "web"]
  }
}

Memory Portability

Export and import memories for backup, migration, or offline access.

Export and import memories
// Export all memories
const exportData = await rekall.memories.export({
  format: 'json',           // 'json' | 'csv' | 'jsonl'
  types: ['episodic', 'semantic'],
  includeEmbeddings: false,  // Embeddings are large
});


// Save to file
await fs.writeFile('rekall-backup.json', JSON.stringify(exportData));


// Import memories into a different account or environment
const importResult = await rekall.memories.import({
  data: exportData,
  strategy: 'merge',        // 'merge' | 'replace' | 'skip-existing'
  recomputeEmbeddings: true, // Recompute for the new environment
});


console.log(`Imported: ${importResult.imported}`);
console.log(`Skipped: ${importResult.skipped}`);
console.log(`Errors: ${importResult.errors}`);

API key scope

Export/import operations require the memory:export and memory:import scopes. Make sure your API key has these permissions. See Scopes & Permissions.

Next Steps

Rekall
rekall