# Memoria — Deterministic AI Memory & Code Intelligence MCP

> Memoria — Deterministic AI Memory & Code Intelligence MCP is a freemium MCP server for knowledge and memory. Deterministic long-term memory and code search for coding agents, with no LLM calls. It runs as a hosted remote server, so there is nothing to install locally.

- **Kind:** MCP server
- **Pricing:** Freemium
- **Starting price:** $19 a month
- **Platforms:** API, CLI, macOS, Windows, Linux
- **Website:** https://memoria.kolivri.com
- **Repository:** https://github.com/kolivritech/memoria-mcp
- **MCP Registry name:** io.github.kolivritech/memoria-mcp
- **Categories:** knowledge and memory, developer tools
- **Listing updated:** 2026-11-14

## About

Memoria stores an agent's memories in a hosted namespace and recalls them by deterministic ranking instead of vector similarity, so the same input gives the same state. The site's pitch is that updated facts suppress outdated ones through typed Supersedes, Causal and DependsOn edges. It reports 500 of 500 on LongMemEval at about 12.9 ms using no LLM tokens; these are the vendor's own benchmark figures.

In day-to-day use, a Claude Code integration reads your working directory, branch and last three commits to load prior decisions before the first prompt. It records corrections such as 'don't do X, use Y' as high-salience rules, snapshots working state before context compaction and restores it after. Slash commands cover diagnostics, indexing a repository, session wrap-up and importing plan files.

Code intelligence tools search, explain and navigate an indexed repository by functions, classes and call graph. The connector is a zero-dependency Node package for stdio or the hosted HTTP endpoint, and a one-line installer configures about 15 clients. It needs a Memoria API key; namespaces keep projects separate.

## Features

- **Deterministic recall:** Ranks memories without LLM calls and returns a token-budgeted context block.
- **Belief revision:** Typed edges let newer facts suppress outdated ones.
- **Code indexing:** Indexes functions, classes, types and call graph for search and navigation.
- **Session continuity:** Snapshots and restores working state around context compaction.
- **Correction learning:** Turns your corrections into high-salience rules.
- **Multi-client install:** One key and installer configure Claude Code, Cursor, Windsurf, OpenCode and others.

## Good for

- Carry decisions and rules across coding sessions
- Stop an agent repeating a mistake you corrected
- Find references and impact of a change in a large repo
- Share one memory namespace between several IDEs

## Install

### Claude Code (Terminal)

```sh
claude mcp add --transport http memoria-mcp https://memoria.kolivri.com/v1/mcp
```

### Claude Desktop (Settings → Connectors → Add custom connector)

```sh
https://memoria.kolivri.com/v1/mcp
```

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

```json
{
  "mcpServers": {
    "memoria-mcp": {
      "url": "https://memoria.kolivri.com/v1/mcp"
    }
  }
}
```

### VS Code (.vscode/mcp.json)

```json
{
  "servers": {
    "memoria-mcp": {
      "type": "http",
      "url": "https://memoria.kolivri.com/v1/mcp"
    }
  }
}
```

### Windsurf (~/.codeium/windsurf/mcp_config.json)

```json
{
  "mcpServers": {
    "memoria-mcp": {
      "serverUrl": "https://memoria.kolivri.com/v1/mcp"
    }
  }
}
```

### Other clients (your client's MCP settings (most use this shape))

```json
{
  "mcpServers": {
    "memoria-mcp": {
      "type": "http",
      "url": "https://memoria.kolivri.com/v1/mcp"
    }
  }
}
```

## Tools

- `encode_memory`: Store a memory with tier classification (episodic, semantic, buffer, core), salience weight, and context metadata.
- `batch_encode`: Atomically store multiple memories in a single batch call.
- `recall_memories`: Retrieve top memories ranked deterministically by BM25, salience, tier weight, and freshness within a token budget.
- `build_context`: Assemble a token-budgeted <memory_context> block combining Core rules, Semantic facts, and Episodic history.
- `forget_memory`: Delete a specific memory and its incident graph edges by ID.
- `delete_by_context`: Delete all memories matching a specific context metadata [key, value] pair.
- `feedback`: Mark a recalled memory as useful or noisy to adjust its salience weight.
- `consolidate`: Merge duplicate memories and promote recurring high-salience episodic items to Semantic tier.
- `health`: Return Memoria Cloud engine health, active memory counts, and quota status.
- `stats`: Return memory counts and 30-day API call quota statistics for a namespace.
- `search_code`: Search indexed code symbol definitions and references stored in Memoria.
- `explain_code`: Explain a symbol or module from indexed code memories, callers, and architectural notes.
- `list_agent_wings`: List specialist multi-agent memory wings (architect, reviewer, qa, security, ops) and their memory counts.
- `handoff_to_agent`: Record a structured multi-agent handoff into a specialist wing (architect, reviewer, qa, security, ops).

## FAQ

### What does it cost?

The README lists 1,000 free API calls and memories, then Developer at $19 per month, Startup at $79 and Business at $299.

### Is it local?

Memory lives in Memoria Cloud; the connector runs locally over stdio or connects to the hosted HTTP endpoint.

### What do I need to connect?

A Memoria API key, set as MEMORIA_API_KEY, and optionally a namespace.

### How are the benchmark numbers produced?

They are the vendor's reported LongMemEval results, not independently verified.

### Is Memoria — Deterministic AI Memory & Code Intelligence MCP free?

Memoria — Deterministic AI Memory & Code Intelligence MCP has a free plan, with paid plans for more usage or features. Paid plans start at $19 a month.

### How do I add Memoria — Deterministic AI Memory & Code Intelligence MCP to Claude Code?

Run this command in your terminal: claude mcp add --transport http memoria-mcp https://memoria.kolivri.com/v1/mcp

### What are the best alternatives to Memoria — Deterministic AI Memory & Code Intelligence MCP?

The closest alternatives to Memoria — Deterministic AI Memory & Code Intelligence MCP are REA, Codebase Memory, GitHub, Serena MCP: the IDE for your agent and XERJ.

## Alternatives

- [REA](https://ai-powered.com/mcp/rea): REA is an open-source MCP server for developer tools.
- [Codebase Memory](https://ai-powered.com/mcp/codebase-memory): Codebase Memory is an open-source MCP server for knowledge and memory.
- [GitHub](https://ai-powered.com/mcp/github-2): GitHub is an open-source MCP server for developer tools.
- [Serena MCP: the IDE for your agent](https://ai-powered.com/mcp/serena-mcp-the-ide-for-your-agent): Serena MCP: the IDE for your agent is an open-source MCP server for developer tools.
- [XERJ](https://ai-powered.com/mcp/xerj): XERJ is an open-source MCP server for knowledge and memory.
- [Ouroboros](https://ai-powered.com/mcp/ouroboros): Ouroboros is an open-source MCP server for developer tools.
- [Claude Code Ultimate Guide](https://ai-powered.com/mcp/claude-code-ultimate-guide): Claude Code Ultimate Guide is an open-source MCP server for ai models and llm tooling.
- [Nautilus Compass Memory](https://ai-powered.com/mcp/nautilus-compass-memory): Nautilus Compass Memory is an open-source MCP server for knowledge and memory.

---
Source: https://ai-powered.com/mcp/memoria-deterministic-ai-memory-and-code-intelligence-mcp
