Documentation

Installation

Get JauMemory up and running in minutes.

Prerequisites

• Node.js 18 or higher
• An MCP client: Claude Desktop, Claude Code, Cursor, Cline, Windsurf, VS Code, Codex CLI, Gemini CLI, Zed, and more (see Configuration) · or claude.ai / ChatGPT via the hosted connector
• A JauMemory account (currently invite-only · request an invite)

Zero-install via npx

No global install needed. Add one block to your MCP client's config and it downloads and runs on demand:

{
  "mcpServers": {
    "jaumemory": {
      "command": "npx",
      "args": ["-y", "@jaumemory/mcp-server"]
    }
  }
}

Quick Start

Three steps from zero to a shared memory across every AI tool you use. Have an invite code? The welcome page walks the same three steps with copy buttons.

1. Create your account

JauMemory is in private beta. Sign up with your invite code at mem.jau.app/signup. No invite yet? Request one.

2. Connect your AI

Using claude.ai or ChatGPT in the browser? No file needed: copy your personal link from the dashboard's MCP Connections page and add it as a connector in the app's settings (the beginner guide walks it through). For desktop clients, add one block to the MCP config (Claude Desktop, Claude Code, Cursor, Cline, Windsurf, Copilot, Codex CLI, and more · exact file paths in Configuration):

{
  "mcpServers": {
    "jaumemory": {
      "command": "npx",
      "args": ["-y", "@jaumemory/mcp-server"]
    }
  }
}

3. Log in and store your first memory

In your AI chat, ask it to log in to JauMemory. Behind the scenes:

// Your assistant calls mcp_login with your account details
mcp_login({ username: "your-username", email: "you@example.com" })
// → returns an approval link (valid 5 minutes)

// You open the link, sign in at mem.jau.app, click Approve,
// and get a short code like "happy-star". Your assistant then calls:
mcp_authenticate({ request_id: "...", auth_token: "happy-star" })

// Done. Now store something:
remember({ content: "Project uses React 18 with TypeScript", tags: ["tech-stack"] })

// ...and recall it from any other connected tool:
recall({ query: "React" })

No passwords and no API keys are ever pasted into the chat. Credentials are stored in your OS keychain (with an AES-256-GCM encrypted file fallback) and sessions refresh automatically.

Configuration

Configure JauMemory with your preferred AI tools. No API keys required - authentication is handled through the secure MCP login flow.

Claude Desktop

Add JauMemory to your Claude Desktop configuration file:

• macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
• Windows: %APPDATA%\Claude\claude_desktop_config.json

{
  "mcpServers": {
    "jaumemory": {
      "command": "npx",
      "args": ["-y", "@jaumemory/mcp-server"]
    }
  }
}

Claude Code

Install via CLI or manual configuration:

# CLI installation (recommended)
claude mcp add jaumemory -- npx -y @jaumemory/mcp-server

# Manual configuration in ~/.claude.json or .mcp.json
{
  "mcpServers": {
    "jaumemory": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@jaumemory/mcp-server"]
    }
  }
}

Cline

Installation (Required):

npm install -g @jaumemory/mcp-server

If using both Windows and WSL, run the install command in both environments:

# In Windows PowerShell
npm install -g @jaumemory/mcp-server

# In WSL terminal
npm install -g @jaumemory/mcp-server

Add to your Cline MCP settings:

{
  "mcpServers": {
    "jaumemory": {
      "type": "stdio",
      "timeout": 60,
      "command": "npx",
      "args": ["-y", "@jaumemory/mcp-server"]
    }
  }
}

Note: The "type": "stdio" and "timeout": 60 settings are important for Cline compatibility. Installing in the correct terminal environment ensures Cline can find and execute the server. The global installation helps avoid Windows file locking issues.

Cursor

Configure in .cursor/mcp.json:

{
  "mcpServers": {
    "jaumemory": {
      "command": "npx",
      "args": ["-y", "@jaumemory/mcp-server"]
    }
  }
}

VS Code (Copilot / native MCP)

Add to .vscode/mcp.json in your workspace:

{
  "servers": {
    "jaumemory": {
      "command": "npx",
      "args": ["-y", "@jaumemory/mcp-server"]
    }
  }
}

Note: in user settings.json the same block sits under an "mcp" key: "mcp": { "servers": { ... } }.

ChatGPT (Developer Mode)

OAuth connection for ChatGPT Plus/Pro users:

{
  "name": "JauMemory",
  "description": "Persistent collaborative shared agent memory",
  "mcp_server_url": "https://mem.jau.app/mcp/",
  "authentication": "OAuth"
}

Note: Find your mcp_id in the User Dashboard → MCP page after signing up.

More clients

The server command is identical everywhere: npx -y @jaumemory/mcp-server (stdio). Only the config file differs.

OpenAI Codex CLI

Add to ~/.codex/config.toml:

[mcp_servers.jaumemory]
command = "npx"
args = ["-y", "@jaumemory/mcp-server"]

Gemini CLI

Add to ~/.gemini/settings.json:

{
  "mcpServers": {
    "jaumemory": {
      "command": "npx",
      "args": ["-y", "@jaumemory/mcp-server"]
    }
  }
}

Zed

Add to Zed's settings.json (Cmd/Ctrl+, → open settings file):

{
  "context_servers": {
    "jaumemory": {
      "command": {
        "path": "npx",
        "args": ["-y", "@jaumemory/mcp-server"]
      }
    }
  }
}

Continue

Add to Continue's config.yaml:

mcpServers:
  - name: JauMemory
    command: npx
    args: ["-y", "@jaumemory/mcp-server"]

Roo Code

Open the MCP Servers panel → Edit MCP Settings, and use the same JSON block as Cline (including "type": "stdio" and "timeout": 60).

Goose

Run goose configure, choose Add Extension → Command-line Extension, and enter npx -y @jaumemory/mcp-server as the command.

LM Studio

In the Program sidebar choose Install → Edit mcp.json and add the standard block:

{
  "mcpServers": {
    "jaumemory": {
      "command": "npx",
      "args": ["-y", "@jaumemory/mcp-server"]
    }
  }
}

Any other MCP client

OpenClaw, Open Hermes, OpenHands, and every other MCP-capable harness can connect too; their config formats change often enough that we won't guess file paths here. In your client's MCP settings, register a stdio server with:

command: npx
args:    -y @jaumemory/mcp-server

If your client takes a remote MCP URL (OAuth connector) instead of a local command, use your personal endpoint from the dashboard's MCP Connections page:

https://mem.jau.app/mcp/<your-mcp-id>

Either way, authentication happens afterwards with mcp_login; there is nothing to paste into the config beyond the above.

Your First Memory

Start using JauMemory immediately after authentication.

Authentication

// Step 1: start the login flow
await mcp_login({
  username: "your-username",
  email: "your-email@example.com"
});
// → returns a request_id and a browser approval link (expires in 5 minutes)

// Step 2: open the link, sign in at mem.jau.app, click Approve,
// and copy the short code shown (e.g. "happy-star")

// Step 3: complete the flow with that code
await mcp_authenticate({
  request_id: "req_abc123",
  auth_token: "happy-star"
});

Credentials are stored in your OS keychain (AES-256-GCM encrypted file fallback) and sessions refresh automatically. To sign out, mcp_logout supports a scope of this (default, this device only), all, or others.

Store Your First Memory

// Basic memory creation
await jaumemory.remember({
  content: "Started learning JauMemory today",
  tags: ["learning", "getting-started"],
  importance: 0.8
});

// Using shortcuts for faster input
await jaumemory.remember({
  content: "Set up development environment",
  shortcuts: ["--task", "--done", "--project setup"]
});

Retrieve Memories

// Search by keyword
const memories = await jaumemory.recall({
  query: "learning",
  limit: 5
});

// Browse recent memories with a time filter (no query needed)
const recent = await jaumemory.recall({
  timeRange: { start: "2026-07-01" }
});

Memory Types

JauMemory uses a hierarchical memory system inspired by human cognition.

Encryption

Your memories are encrypted at rest with a key unique to your account, and encrypted in transit with TLS.

Security Architecture

JauMemory uses server-side, per-user encryption. Every memory is encrypted with your account's own AES-256-GCM key before it is written to the database, and all traffic between your MCP client and the server travels over TLS (HTTPS for the API, TLS for gRPC). There is nothing to configure: encryption is always on and cannot be disabled.

Technical Details

• At rest: per-user AES-256-GCM encryption of memory content
• In transit: TLS everywhere (HTTPS + gRPC over TLS)
• Isolation: PostgreSQL row-level security scopes every query to your user
• Key derivation: PBKDF2
• Sessions: per-device, individually revocable; TOTP 2FA available
• Your data: GDPR-compliant export from the dashboard, right to deletion

Multi-Agent Coordination

Coordinate multiple AI agents with shared memory and task distribution.

Creating Agents

// Create specialized agents
await jaumemory.create_agent({
  name: "Frontend Expert",
  specializations: ["React", "TypeScript", "CSS"],
  personalityTraits: ["detail-oriented", "creative"]
});

Task Assignment

// Assign tasks to specific agents
await jaumemory.remember({
  content: "Implement dark mode toggle",
  shortcuts: ["--task", "--assign @frontend-expert", "--high"]
});

// Agents coordinate via the unified agent_collaboration tool:
// start a collaboration, complete it with an outcome, or list active ones.
await jaumemory.agent_collaboration({
  action: "start",
  agentId: "frontend-expert",
  collaboratorId: "backend-dev",
  collaborationType: "code-review"
});

const active = await jaumemory.agent_collaboration({
  action: "list",
  agentId: "frontend-expert"
});

Shortcuts Quick Reference

Speed up memory creation with our comprehensive shortcuts system.

Searching Memories

recall supports three search modes and composable filters. The query is optional: you can search by filters alone.

Search Modes

// Hybrid (the default): keyword + semantic combined
await jaumemory.recall({ query: "authentication bug" });

// Keyword only: exact-term matching
await jaumemory.recall({ query: "TAR_ENTRY_ERROR", mode: "keyword" });

// Semantic only: meaning-based matching, no third-party AI APIs involved
await jaumemory.recall({ query: "login problems", mode: "semantic" });

Filters

// By tags (matches ANY of the listed tags)
await jaumemory.recall({ tags: ["diary", "achievement"], limit: 20 });

// By time range
await jaumemory.recall({
  query: "deploy",
  timeRange: { start: "2026-06-01", end: "2026-06-30" }
});

// By importance
await jaumemory.recall({ query: "architecture", minImportance: 0.7 });

// Filters-only search: no query needed
await jaumemory.recall({ tags: ["bug"], minImportance: 0.8 });

Real-World Examples

See JauMemory in action with practical debugging and project management workflows.

Debugging Workflow

// 1. Document the error
await jaumemory.remember({
  content: "Users getting 403 on /api/profile after login",
  shortcuts: ["--bug", "--high", "--project auth-service"]
});

// 2. Track investigation
await jaumemory.remember({
  content: "JWT token valid. Checking middleware next.",
  shortcuts: ["--note", "--wip"]
});

// 3. Record the solution
await jaumemory.remember({
  content: "Permission mismatch: DB has 'users:read' but code checks 'user:read'",
  shortcuts: ["--solution", "--assign @backend-dev"]
});

// 4. Later, instantly find similar issues
const similar = await jaumemory.recall({ query: "403 authentication" });

Project Management

// Create project structure
await jaumemory.remember({
  content: "Build Todo App MVP",
  shortcuts: ["--task", "--high", "--project todo-app"]
});

// Break down into subtasks
await jaumemory.remember({
  content: "Design todo list UI",
  shortcuts: ["--task", "--assign @frontend-dev", "--parent todo-mvp"]
});

// Track blockers
await jaumemory.remember({
  content: "API endpoint implementation",
  shortcuts: ["--task", "--blocked waiting for API specs"]
});

// Daily standup query: shortcuts are parsed into tags server-side,
// so filter on the matching tags
const standup = await jaumemory.recall({
  query: "todo-app",
  tags: ["wip", "blocked"]
});

Memory Analysis & Insights

Let JauMemory analyze your patterns and surface valuable insights.

Pattern Detection

// Analyze patterns over a time window: "day", "week", "month", or "all"
const insights = await jaumemory.analyze({ timeRange: "month" });

// Returns memory counts by type (error / solution / insight / question)
// and recurring patterns detected across your memories.

Memory Consolidation

// Preview what would be merged, without changing anything
await jaumemory.consolidate({ dry_run: true });

// Merge similar memories into insights
await jaumemory.consolidate({
  similarity_threshold: 0.7,   // default 0.7
  min_group_size: 2,           // default 2
  archive_originals: true      // default true
});

// Creates insights from patterns:
// "Multiple React re-render issues → Consider React.memo for lists"

Security & Privacy

Your memories are yours alone. We're just the guardians.

Custom Skills

Skills are reusable, named pipelines of tool calls and LLM steps. Define a skill once, then trigger it by phrase, schedule, or direct execution.

Define a Skill

// Define a research skill
await jaumemory.skill_create({
  slug: "weekly-tech-summary",
  name: "Weekly Tech News Summary",
  description: "Summarize top 5 tech stories from this week",
  pipeline: [
    { type: "tool_call", tool: "hackernews-top", input: { limit: 5 } },
    { type: "llm", prompt: "Summarize each story in 2 sentences" }
  ],
  trigger_phrases: ["tech summary", "weekly tech"]
});

Render & Execute

// Inspect a skill before running it
await jaumemory.skill_render({ slug: "weekly-tech-summary" });

// Execute on demand
await jaumemory.skill_execute({
  slug: "weekly-tech-summary",
  inputs: {}
});

// List all skills
await jaumemory.skill_list({ limit: 20 });

Skill Scheduling

Run skills automatically on a cron-style schedule. Schedules respect timezones and survive server restarts.

Schedule a Recurring Skill

// Run every Monday at 9am Eastern
await jaumemory.skill_schedule({
  skill_id: "weekly-tech-summary",
  cron_expression: "0 9 * * 1",
  timezone: "America/New_York"
});

// List all schedules
await jaumemory.skill_schedule_list({});

// Cancel a schedule
await jaumemory.skill_schedule_cancel({ schedule_id: "abc-123" });

// Re-trigger a schedule's most recent run
await jaumemory.skill_schedule_retrigger({ schedule_id: "abc-123" });

Skill Tasks

Long-running skills execute as async tasks. Inspect history, retrigger failed runs, and watch what's pending.

// What's currently pending?
await jaumemory.skill_tasks_pending({});

// Full task history
await jaumemory.skill_tasks_list({ limit: 50 });

// Retrigger a specific task (e.g. one that errored)
await jaumemory.skill_task_retrigger({ task_id: "task-789" });

Tool Registry

Register custom HTTP tools (APIs, webhooks, internal services) into your private registry. Tools become callable from skills, agents, and direct invocation.

Register a Tool

// Create a tool that wraps an external API
await jaumemory.tool_create({
  slug: "hackernews-top",
  name: "Hacker News Top Stories",
  description: "Fetch top N stories from Hacker News",
  endpoint: "https://hacker-news.firebaseio.com/v0/topstories.json",
  method: "GET",
  parameters: {
    limit: { type: "number", default: 10 }
  }
});

// Update an existing tool
await jaumemory.tool_update({
  slug: "hackernews-top",
  description: "Updated description"
});

// Inspect the tool definition
await jaumemory.tool_render({ slug: "hackernews-top" });

// List all tools you've registered
await jaumemory.tool_list({});

// Call a tool directly
await jaumemory.tool_call({
  slug: "hackernews-top",
  input: { limit: 5 }
});

Toolkit Search

Semantic discovery across every tool and skill in your registry. Use it when you don't know the exact slug: describe what you need and the toolkit returns the best matches.

// "I need to summarize tech news" · find matching skills/tools
const matches = await jaumemory.toolkit_search({
  query: "summarize tech news this week",
  limit: 5
});

// Returns ranked results with slugs, descriptions, and trigger phrases.
// Pass the chosen slug into skill_execute or tool_call.

Berrry Integration

Berrry apps can be registered as JauMemory tools in one call, or generated from scratch and registered automatically.

// Register an existing Berrry app as a tool
await jaumemory.berrry_register_tool({
  app_url: "https://berrry.app/",
  slug: "weather-check"
});

// Generate a new Berrry app and auto-register it as a tool
await jaumemory.berrry_create_tool({
  prompt: "App that returns today's weather for a given city",
  slug: "weather-today"
});

Vault Storage

The Credential Vault stores API keys, tokens, and secrets, encrypted with your per-user AES-256-GCM key. Skills and tools reference credentials by slug, never by raw value.

Store a Credential

// Store an API credential
await jaumemory.vault_store({
  slug: "openai-prod",
  type: "api_key",
  value: "sk-...",
  description: "OpenAI prod key · used by skills"
});

// List your vault entries (slugs & metadata only · values are never returned)
await jaumemory.vault_list({});

Credential Rotation

Rotate keys without breaking downstream skills. The slug stays stable; only the underlying value changes.

// Rotate a credential in place
await jaumemory.vault_rotate({
  slug: "openai-prod",
  new_value: "sk-newkey..."
});

OAuth: ChatGPT Custom GPT

JauMemory exposes an OAuth 2.1 MCP endpoint that ChatGPT Plus/Pro can connect to as a custom connector.

{
  "name": "JauMemory",
  "description": "Persistent collaborative shared agent memory",
  "mcp_server_url": "https://mem.jau.app/mcp/<mcp_id>",
  "authentication": "OAuth"
}

Your mcp_id is shown in the User Dashboard → MCP page. The OAuth handshake is browser-based, with no API keys to manage.

OAuth: Claude Desktop

Claude Desktop authenticates via the standard MCP login flow. The first call to mcp_login returns a browser approval URL (valid for 5 minutes); copy the short code from the approval page back into mcp_authenticate.

// Step 1: get an approval URL
const { request_id, approval_url } = await jaumemory.mcp_login({
  username: "your-username",
  email: "you@example.com"
});

// User opens approval_url, signs in at mem.jau.app, clicks Approve,
// and gets a short human-readable code (e.g. "happy-star")

// Step 2: complete authentication
await jaumemory.mcp_authenticate({
  request_id,
  auth_token: "happy-star"  // the code from the approval page
});

// Sign out later. scope: "this" (default) | "all" | "others"
await jaumemory.mcp_logout({ scope: "this" });

OAuth: Generic OAuth 2.1

Any OAuth 2.1 MCP client (Cursor, Cline, Claude Code, Windsurf, VS Code Copilot, custom agents) can connect to your personal MCP endpoint https://mem.jau.app/mcp/<mcp_id> using standard OAuth 2.1 with PKCE. Endpoints are auto-discovered via RFC 8414 metadata:

• Discovery: https://mem.jau.app/.well-known/oauth-authorization-server
• Authorization endpoint: https://mem.jau.app/v1/authorize
• Token endpoint: https://mem.jau.app/v1/token
• Dynamic client registration: https://mem.jau.app/register (RFC 7591)
• PKCE: required (S256)
• Scopes: mcp.tools, mcp.resources
• Bearer tokens: short-lived access tokens with refresh