io.github.thelabvenice/memdata

Official

by thelabvenice · JavaScript

Persistent memory for AI agents. Store context, retrieve it semantically.

Persistent memory system for AI agents to store and semantically retrieve context.

README.md10 KBView on GitHub

memdata-mcp

MCP server for MemData - persistent memory for AI agents.

Give Claude, Cursor, or any MCP-compatible AI long-term memory across conversations.

What it does: Store notes, decisions, and context → retrieve them semantically later. Your AI remembers everything.

🚀 New in v1.7.0: Autonomous Agent Support

Agents can now pay for themselves. No API key. No human in the loop.

Using the x402 payment protocol, autonomous agents can use their wallet to pay per request with USDC on Base. Your wallet address IS your identity - same wallet, same memories across sessions.

Jump to For Agents →

Why MemData?

AI assistants forget everything between sessions. MemData fixes that:

Ingest → Drop in meeting notes, docs, decisions
Chunk & Embed → Automatically split and vectorize
Query → Ask questions, get relevant context back
Tag → AI auto-tags content for better retrieval

Works with Claude Desktop, Claude Code, Cursor, and any MCP client.

👤 For Humans

Use an API key. You manage the subscription, your AI gets memory.

Setup

Get your API key at memdata.ai/dashboard/api-keys
Add to your MCP config:

Claude Desktop (~/Library/Application Support/Claude/claude_desktop_config.json):

json

{
  "mcpServers": {
    "memdata": {
      "command": "npx",
      "args": ["memdata-mcp"],
      "env": {
        "MEMDATA_API_KEY": "md_your_key"
      }
    }
  }
}

Claude Code (~/.claude.json or project .mcp.json):

json

{
  "mcpServers": {
    "memdata": {
      "command": "npx",
      "args": ["memdata-mcp"],
      "env": {
        "MEMDATA_API_KEY": "md_your_key"
      }
    }
  }
}

Cursor (~/.cursor/mcp.json):

json

{
  "mcpServers": {
    "memdata": {
      "command": "npx",
      "args": ["memdata-mcp"],
      "env": {
        "MEMDATA_API_KEY": "md_your_key"
      }
    }
  }
}

Restart your client - you should now see MemData tools available.

🤖 For Agents

New in v1.7.0 - No API key. No human. Just your wallet.

Why This Matters

Traditional AI memory requires API keys tied to human accounts. But autonomous agents running 24/7 need memory that:

Outlives any single conversation - persist across hosts and platforms
Belongs to the agent - wallet address = identity, portable and self-sovereign
Pays for itself - no subscription, no human approval needed

This is memory infrastructure for the autonomous agent economy.

Setup

json

{
  "mcpServers": {
    "memdata": {
      "command": "npx",
      "args": ["memdata-mcp"],
      "env": {
        "X402_WALLET_KEY": "your_private_key_hex"
      }
    }
  }
}

How it works

Agent makes a request (query, ingest, etc.)
Server returns 402 Payment Required with price
MCP automatically signs payment with agent's wallet
Request completes - memory stored/retrieved

Your wallet address IS your identity. Same wallet = same memories, across any host or platform.

Pricing (USDC on Base)

Operation	Price	What it does
Query	$0.001	Semantic search across memories
Ingest	$0.005	Store and embed new content
Identity	$0.001	Session start, get/set agent identity
Artifacts	$0.001	List or delete stored memories

The MCP automatically handles 402 responses and payment signatures using @x402/fetch.

Learn More

x402 Protocol - HTTP-native payments
ERC-8004 - Trustless Agents standard (MemData is aligned)

Supported Content

Type	MCP	Dashboard/API	Processing
Text	✅	✅	Chunked & embedded
Markdown	✅	✅	Chunked & embedded
PDF	❌	✅	OCR + chunking
Images (PNG, JPG)	❌	✅	OCR extraction
Audio (MP3, WAV, M4A)	❌	✅	Transcription

Note: MCP tools handle text content directly. For files (PDFs, images, audio), use the dashboard or HTTP API.

Tools

Core Tools

Tool	Description
`memdata_ingest`	Store text in long-term memory
`memdata_query`	Search memory with natural language
`memdata_list`	List all stored memories
`memdata_delete`	Delete a memory by ID
`memdata_status`	Check API health and storage usage

Identity & Session Tools (v1.2.0+)

Tool	Description
`memdata_session_start`	🚀 CALL FIRST - Get identity, last session handoff, recent activity
`memdata_set_identity`	Set your agent name and identity summary
`memdata_session_end`	Save a handoff before session ends - preserved for next session
`memdata_query_timerange`	Search with date filters (since/until)
`memdata_relationships`	Find related entities (people, companies, projects)

v1.5.0 - Session Start Rename

memdata_whoami → memdata_session_start - Renamed for clarity. The name now signals "call this first at every session". Description includes 🚀 emoji to catch attention in tool lists.

v1.4.0 UX Improvements

Visual match quality - Query results show 🟢🟡🟠🔴 indicators for match strength
Smarter session_start - Prompts to set identity on first use, deduplicates recent activity
Better ingest feedback - Shows chunk count and explains async AI tagging
Session continuity - Emphasizes "Continue Working On" and reminds to use session_end

`memdata_ingest`

Store text in long-term memory.

code

"Remember that we decided to use PostgreSQL for the new project."

Parameters:

content (string) - Text to store
name (string) - Source identifier (e.g., "meeting-notes-jan-29")

`memdata_query`

Search memory with natural language.

code

"What database did we choose?"

Parameters:

query (string) - Natural language search
limit (number, optional) - Max results (default: 5)

`memdata_list`

List all stored memories with chunk counts.

`memdata_delete`

Delete a memory by artifact ID (get IDs from memdata_list).

`memdata_status`

Check API connectivity and storage usage.

`memdata_session_start`

🚀 Call this first at the start of every session. Essential for session continuity.

code

"Start my session" / "What was I working on?"

Returns: agent name, identity summary, session count, last session handoff, recent activity.

v1.5.0: Renamed from memdata_whoami for clarity - the name signals "call me first".

`memdata_set_identity`

Set or update your agent identity.

Parameters:

agent_name (string, optional) - Your name (e.g., "MemBrain")
identity_summary (string, optional) - Who you are and your purpose

`memdata_session_end`

Save context before ending a session. Next session will see this handoff.

Parameters:

summary (string) - What happened this session
working_on (string, optional) - Current focus
context (object, optional) - Additional context to preserve

`memdata_query_timerange`

Search memory within a date range.

code

"What did I work on last week?"

Parameters:

query (string) - Natural language search
since (string, optional) - ISO date (e.g., "2026-01-01")
until (string, optional) - ISO date (e.g., "2026-01-31")
limit (number, optional) - Max results

`memdata_relationships`

Find entities that appear together in your memory.

code

"Who has John Smith worked with?"

Parameters:

entity (string) - Name to search for
type (string, optional) - Filter by type (person, company, project)
limit (number, optional) - Max relationships

How it works

Ingest: Text is chunked, embedded, and stored
Query: Your question is matched against stored memories using semantic similarity
Results: Returns relevant content with similarity scores

Scores of 30-50% are typical for good matches. Semantic search finds meaning, not keywords.

Environment Variables

Variable	Required	Description
`MEMDATA_API_KEY`	Option 1	API key for subscribers (from memdata.ai)
`X402_WALLET_KEY`	Option 2	Private key for pay-per-use (USDC on Base)
`MEMDATA_API_URL`	No	API URL (default: https://memdata.ai)

Note: Use either MEMDATA_API_KEY (subscription) or X402_WALLET_KEY (pay-per-use), not both.

What this package does

This is a thin MCP client that calls the MemData API. It does not:

Store any data locally
Send data anywhere except memdata.ai
Collect analytics or telemetry

You can inspect the source code in src/index.ts.

Example Usage

Once configured, just talk to your AI:

code

You: "Remember that we chose PostgreSQL for the user service"
AI: [calls memdata_ingest] → Stored in memory

... days later ...

You: "What database are we using for users?"
AI: [calls memdata_query] → "PostgreSQL for the user service" (73% match)

Contributing

Issues and PRs welcome! This is the open-source MCP client for the hosted MemData service.

License

MIT

Install

Configuration

Environment variables

MEMDATA_API_KEYrequiredsecret

Your MemData API key (get one at memdata.ai/dashboard/api-keys)

claude_desktop_config.json

{
  "mcpServers": {
    "memdata": {
      "command": "npx",
      "args": [
        "-y",
        "memdata-mcp@1.4.1"
      ],
      "env": {
        "MEMDATA_API_KEY": "<YOUR_MEMDATA_API_KEY>"
      }
    }
  }
}

memdata-mcp

🚀 New in v1.7.0: Autonomous Agent Support

Why MemData?

👤 For Humans

Setup

🤖 For Agents

Why This Matters

Setup

How it works

Pricing (USDC on Base)

Learn More

Supported Content

Tools

Core Tools

Identity & Session Tools (v1.2.0+)

v1.5.0 - Session Start Rename

v1.4.0 UX Improvements

memdata_ingest

memdata_query

memdata_list

memdata_delete

memdata_status

memdata_session_start

memdata_set_identity

memdata_session_end

memdata_query_timerange

memdata_relationships

How it works

Environment Variables

What this package does

Example Usage

Links

Contributing

License

Install

Configuration

`memdata_ingest`

`memdata_query`

`memdata_list`

`memdata_delete`

`memdata_status`

`memdata_session_start`

`memdata_set_identity`

`memdata_session_end`

`memdata_query_timerange`

`memdata_relationships`