What can you do with this server?

Central Intelligence provides persistent memory for AI agents, enabling them to store, retrieve, and manage information across sessions. * remember – Store information (user preferences, project decisions, facts) in persistent memory with optional tags and a visibility scope (agent, user, or org). * recall – Semantically search stored memories using natural language queries, with optional filtering by tags, scope, and result limit. * context – Automatically retrieve the most relevant memories based on your current task or discussion, ideal for loading context at session start. * forget – Delete a specific memory by ID when it becomes outdated or incorrect. * share – Broaden a memory's visibility from agent scope to user or org scope for collaborative access across agents. * Manage API keys & monitor usage – Create/manage API keys and check usage statistics including memory counts and active agents. * Flexible integration – Works with Claude Code, Cursor, LangChain, CrewAI, and any MCP-compatible agent platform. * Flexible deployment – Use the hosted service or self-host, with CLI and REST API support for programmatic management.

Which integrations are available for this server?

Facilitates shared knowledge and context continuity for CrewAI multi-agent systems, enabling agents to store and retrieve information across different tasks. Enables LangChain-based agents to maintain persistent state and context through semantic search and cross-session memory storage.

de en es ja ko ru zh

Central Intelligence

by AlekseiMarchenko

Overview Schema Related Servers Score Discussions

TypeScript

Hybrid

Central Intelligence

Agents forget. CI remembers.

Persistent memory for AI agents. Store, recall, and share information across sessions. Works with Claude Code, Cursor, LangChain, CrewAI, and any agent that supports MCP.

CI never rewrites your memories. Facts are extracted for search, but your content is always returned verbatim. No junk memories, no hallucinated rewrites, no data loss.

npm License: Apache 2.0

Central Intelligence MCP server

Quick Start (30 seconds)

# 1. Get an API key
npx central-intelligence-cli signup

# 2. Add to Claude Code
npx central-intelligence-cli init claude

# Done. Your agent now has persistent memory.

When to Use Central Intelligence

Heuristic: If you would write it in a note to your future self, store it in Central Intelligence.

Scenario	What to do
Starting a new session, need context from before	`recall` or `context`
Discovered something important (architecture, preferences, fixes)	`remember`
Multiple agents working on the same project	`share` with user/org scope
You keep re-learning the same things each session	`remember` once, `recall` forever
Handing off a task to another agent or session	`remember` key decisions, next agent calls `context`
User tells you the same preferences repeatedly	`remember` them, check with `recall` next time

Don't store: secrets, passwords, API keys, PII, large binary files, or ephemeral scratch data.

The Problem

Every AI agent session starts from zero. Your agent learns your preferences, understands your codebase, figures out your architecture — then the session ends and it forgets everything. Next session? Same questions. Same mistakes. Same context-building from scratch.

Central Intelligence fixes this.

What It Does

Five MCP tools give your agent a long-term memory:

Tool	Description	Example
`remember`	Store information for later	"User prefers TypeScript and deploys to Fly.io"
`recall`	Semantic search across past memories	"What does the user prefer?"
`context`	Auto-load relevant memories for the current task	"Working on the auth system refactor"
`forget`	Delete outdated or incorrect memories	`forget("memory_abc123")`
`share`	Make memories available to other agents	scope: "agent" → "org"

Benchmarks

LifeBench (2026) — Long-Term Multi-Source Memory

CI scores 45.9% on LifeBench, the hardest published memory benchmark (2,003 questions across 10 users, 51K real-world events including messages, calendar, health records, notes, and calls).

Overall	Info Extraction	Multi-hop	Temporal
45.9%	52.8%	45.6%	39.3%

Evaluation harness: lifebench-eval

Agent Memory Benchmark (AMB) — Infrastructure Testing

Test CI against other providers using the open-source Agent Memory Benchmark:

npx agent-memory-benchmark --provider central-intelligence --api-key $CI_API_KEY

Note: AMB is maintained by the same author as Central Intelligence. Run it yourself and verify the results. PRs with new provider adapters are welcome.

Cross-Tool Memory

CI Local reads config files from 5 AI coding platforms and makes them searchable alongside your stored memories:

Platform	Config file	How it's parsed
Claude Code	`CLAUDE.md`	Section-based (## headings)
Cursor	`.cursor/rules`	Paragraph-based
Windsurf	`.windsurf/rules`	Paragraph-based
Codex	`codex.md`	Section-based
GitHub Copilot	`.github/copilot-instructions.md`	Section-based

Memories stored via Claude Code are discoverable when using Cursor, and vice versa. Your AI memory works everywhere, not just in one tool.

Recall responses now include source (which tool the memory came from), freshness_score (how recent), and duplicate_group (near-duplicate detection across tools).

How It Works

Agent (Claude, Cursor, Windsurf, Copilot, Codex)
    ↓ MCP protocol
Central Intelligence MCP Server (local, thin client)
    ↓
SQLite + vector embeddings + config file parsing
    ↓
Hybrid search: vector + FTS5 + fuzzy + temporal decay
    ↓
Central Intelligence API (hosted)
    ↓
PostgreSQL + pgvector + fact decomposition + entity graph
    ↓
4-way retrieval: vector + BM25 + graph traversal + temporal
    ↓
Local ONNX cross-encoder reranker (zero API cost)

Every memory is decomposed into structured facts with entities, temporal info, and causal relations. Recall runs four search strategies in parallel (vector similarity, BM25 full-text, entity graph traversal, temporal proximity), fuses results with Reciprocal Rank Fusion, and reranks with a local cross-encoder model. Config files from all supported platforms are parsed, embedded, and cached locally.

Memory Scopes

Scope	Visible to	Use case
`agent`	Only the agent that stored it	Personal context, session continuity
`user`	All agents serving the same user	User preferences, cross-tool context
`org`	All agents in the organization	Shared knowledge, team decisions

MCP Server Setup

Claude Code

Add to ~/.claude/settings.json under mcpServers:

{
  "central-intelligence": {
    "command": "npx",
    "args": ["-y", "central-intelligence-mcp"],
    "env": {
      "CI_API_KEY": "your-api-key"
    }
  }
}

Cursor

Add to ~/.cursor/mcp.json:

{
  "mcpServers": {
    "central-intelligence": {
      "command": "npx",
      "args": ["-y", "central-intelligence-mcp"],
      "env": {
        "CI_API_KEY": "your-api-key"
      }
    }
  }
}

Any MCP-Compatible Client

The MCP server is published as central-intelligence-mcp on npm. Point your MCP client to it with the CI_API_KEY environment variable set.

CLI Usage

# Sign up and get an API key
npx central-intelligence-cli signup

# Add to Claude Code / Cursor
npx central-intelligence-cli init claude
npx central-intelligence-cli init cursor

# Store a memory
npx central-intelligence-cli remember "The user prefers dark mode and TypeScript"

# Search memories
npx central-intelligence-cli recall "what are the user's preferences?"

# Delete a memory
npx central-intelligence-cli forget <memory-id>

# Check connection
npx central-intelligence-cli status

Or install globally for shorter commands:

npm install -g central-intelligence-cli
ci-memory signup
ci-memory remember "User prefers TypeScript"
ci-memory recall "language preferences"

REST API

Base URL: https://central-intelligence-api.fly.dev

All endpoints require Authorization: Bearer <api-key> header.

Create API Key

curl -X POST https://central-intelligence-api.fly.dev/keys \
  -H "Content-Type: application/json" \
  -d '{"name": "my-key"}'

POST /memories/remember

{
  "agent_id": "my-agent",
  "content": "User prefers TypeScript over Python",
  "tags": ["preference", "language"],
  "scope": "agent"
}

POST /memories/recall

{
  "agent_id": "my-agent",
  "query": "what programming language does the user prefer?",
  "limit": 5
}

Response:

{
  "memories": [
    {
      "id": "uuid",
      "content": "User prefers TypeScript over Python",
      "relevance_score": 0.434,
      "tags": ["preference", "language"],
      "scope": "agent",
      "created_at": "2026-03-22T21:42:34.590Z"
    }
  ]
}

POST /memories/context

{
  "agent_id": "my-agent",
  "current_context": "Setting up a new web project for the user",
  "max_memories": 5
}

DELETE /memories/:id

POST /memories/:id/share

{
  "target_scope": "org"
}

GET /usage

Returns memory counts, usage events, and active agents for the authenticated API key.

Self-Hosting

# Clone and install
git clone https://github.com/AlekseiMarchenko/central-intelligence.git
cd central-intelligence
npm install

# Set up PostgreSQL
createdb central_intelligence
psql -d central_intelligence -f packages/api/src/db/schema.sql

# Configure
cp .env.example .env
# Edit .env: set DATABASE_URL and OPENAI_API_KEY

# Run
npm run dev:api

Deploy to Fly.io

fly apps create my-ci-api
fly postgres create --name my-ci-db
fly postgres attach my-ci-db
fly secrets set OPENAI_API_KEY=sk-...
fly deploy

Then point the MCP server to your instance:

{
  "env": {
    "CI_API_KEY": "your-key",
    "CI_API_URL": "https://your-app.fly.dev"
  }
}

Architecture

central-intelligence/
├── packages/
│   ├── api/            # Backend API (Hono + PostgreSQL + pgvector)
│   │   ├── src/
│   │   │   ├── db/           # Schema, migrations (facts, entities, pgvector, hybrid)
│   │   │   ├── middleware/   # Auth, rate limiting, billing, x402 payments
│   │   │   ├── routes/       # REST endpoints, dashboard, docs, demo
│   │   │   └── services/     # Core logic:
│   │   │       ├── memories.ts          # Store + 4-way recall pipeline
│   │   │       ├── fact-extraction.ts   # GPT-4o-mini fact decomposition
│   │   │       ├── entity-resolution.ts # Trigram + co-occurrence entity merging
│   │   │       ├── observations.ts      # Auto-synthesized higher-level facts
│   │   │       ├── rerank.ts            # ONNX local + Cohere + passthrough
│   │   │       ├── embeddings.ts        # OpenAI text-embedding-3-small
│   │   │       ├── encryption.ts        # AES-256-GCM at rest
│   │   │       └── query-decompose.ts   # Query expansion via GPT-4o-mini
│   │   └── tests/        # 68 tests (Vitest)
│   ├── mcp-server/     # MCP server (npm: central-intelligence-mcp)
│   ├── cli/            # CLI tool (npm: central-intelligence-cli)
│   ├── local/          # Local memory with cross-tool config parsing
│   ├── node-sdk/       # Node.js/TypeScript SDK (npm: central-intelligence-sdk)
│   ├── python-sdk/     # Python SDK (PyPI: central-intelligence)
│   └── openclaw-skill/ # OpenClaw skill file
├── .github/workflows/  # CI (typecheck + test) + Deploy (Fly.io)
├── landing/            # Landing page
├── Dockerfile          # API container (non-root, ONNX model pre-cached)
├── fly.toml            # Fly.io config (iad region, health checks)
└── README.md

Pricing

Tier	Price	Memories	Agents
Free	$0	500	1
Pro	$29/mo	50,000	20
Team	$99/mo	500,000	Unlimited

Contributing

Contributions welcome. Open an issue or PR.

License

Apache 2.0

Install Server

security – no known vulnerabilities

license - permissive license

quality - A tier

How are these scores calculated?

Resources

GitHub Repository

Need Help?

Related Servers

Tools

Appeared in Searches

A server for finding information about memory

Latest Blog Posts

Tool Definition Quality Score (TDQS)
By punkpeye on April 3, 2026.
mcp
The Hackers Who Tracked My Sleep Cycle
By punkpeye on March 26, 2026.
security
Open Source Has a Bot Problem
By punkpeye on March 19, 2026.
open source

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/AlekseiMarchenko/central-intelligence'

If you have feedback or need assistance with the MCP directory API, please join our Discord server