Model Context Protocol

Model Context Protocol (MCP) is an open standard that connects AI agents to external tools and data sources. MemNexus uses MCP to give agents native access to memory operations — no custom code required.

What MCP solves

Without MCP, connecting an AI agent to memory requires:

Building a custom integration for each platform
Managing authentication and API calls in your code
Translating between the agent's format and your API

With MCP, you configure a server once and every MCP-compatible agent gets access automatically.

How it works

┌──────────────────┐
│  AI Agent        │  Claude Desktop, Claude Code, Cursor
│  (MCP Client)    │
└────────┬─────────┘
         │ MCP Protocol (JSON-RPC over stdio)
         ▼
┌──────────────────┐
│  MemNexus MCP    │  Translates MCP calls to REST API calls
│  Server          │
└────────┬─────────┘
         │ HTTPS
         ▼
┌──────────────────┐
│  MemNexus API    │  Handles auth, rate limiting, data operations
└──────────────────┘

The AI agent discovers available tools from the MCP server
When the agent wants to use memory, it calls the appropriate MCP tool
The MCP server translates the call to a REST API request
The response flows back through the same path

MCP concepts

Tools

Tools are functions the agent can call. MemNexus exposes 12 tools for memory management, conversations, the knowledge graph, behavioral patterns, and account operations. Each tool has:

Name — How the agent references it (e.g., search_memories)
Description — What the tool does (used by the agent to decide when to call it)
Parameters — Input schema with types and descriptions
Return type — What the tool returns

Resources (future)

MCP also supports resources — data the agent can read without making a tool call. MemNexus may expose frequently-accessed data (like recent memories or active conversations) as resources in a future version.

Why MCP for memory

MCP is a natural fit for memory because:

Discovery — Agents can discover what memory tools are available
Autonomy — Agents decide when to search or save based on context
Standardization — Works across Claude, Cursor, and any MCP client
Separation — Memory logic stays in the server, not in prompts

MCP vs. SDK vs. CLI

Approach	Best for	How it works
MCP	AI agents (Claude, Cursor)	Agent calls tools natively via protocol
SDK	Custom applications	Your code calls the SDK programmatically
CLI	Developers in terminal	You run commands manually

MCP is for agents. SDK is for applications. CLI is for humans. All three access the same API.

Supported platforms

Platform	MCP support	Config via
Claude Desktop	Native	`mx setup claude-desktop`
Claude Code	Native	`mx setup claude-code` → `.mcp.json`
Cursor	Native	`mx setup cursor` → `.cursor/mcp.json`
Windsurf	Native	Manual — add `mx mcp serve` in Settings → MCP
ChatGPT Desktop	Native (remote MCP)	`mx setup chatgpt`

mx setup also supports copilot (GitHub Copilot in VS Code) and codex (OpenAI Codex CLI).

Getting started

See MCP Integration for the full setup guide and tool reference.