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:

1. Building a custom integration for each platform
2. Managing authentication and API calls in your code
3. 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
└──────────────────┘

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

MCP concepts

Tools

Tools are functions the agent can call. MemNexus exposes 19 tools for memory management, conversations, topics, patterns, and advanced queries. 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:

1. Discovery — Agents can discover what memory tools are available
2. Autonomy — Agents decide when to search or save based on context
3. Standardization — Works across Claude, Cursor, and any MCP client
4. 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 location
Claude Desktop	Native	~/.config/claude/claude_desktop_config.json
Claude Code	Native	MCP settings
Cursor	Native	.cursor/mcp.json
Windsurf	Native	MCP settings
ChatGPT	Via Custom GPT actions	N/A (uses REST API directly)

Getting started

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