Statecore MCP

Name: Statecore MCP
Author: yul761

by yul761version 0.1.2i★ –iRuns on your computer

Registry nameio.github.yul761/statecore-mcp

Install

Overview

Description from the maker (original English)

Auditable memory for coding agents: evidence chains, supersession history, keyless embedded SQLite

PopNx MCP’s three pillars

These three are never merged into one score: opinions, measurements and popularity are different things.

User voiceiNo reviews yetReviews open together with accounts in a later step
Our basic checksi1 of 1 passedChecked from public information; code not scanned yet
UsageiNot measured yet★ –

What you can do with it

We have not written a plain-language summary for this one yet. Below are the facts we read from the registry.

Connection: Runs on your computer
Transport: stdio
Category: Search & AI memory
You need to fill in: MODEL_API_KEY

Install

Pick the AI app you use, then copy the settings.

Before you install

Basic checks: 1 of 1 passed
Runs on your computer with your user’s permissions (files, network, apps).
You fill in yourself: STATECORE_SCOPE, FEATURE_LLM, MODEL_API_KEY, MODEL_BASE_URL, MODEL_NAME

Values marked secret are keys to your account. Never share them or paste them into a chat.

You need

npmNode.js installed (for the npx command)

Which app do you use?

ClaudeClaude CodeCursorVS CodeChatGPT

Pick your app above. We remember it, so next time the button says “Install in …”.

Open Claude Desktop → Settings → Developer → Edit Config, and paste this into claude_desktop_config.json

{
  "mcpServers": {
    "statecore": {
      "command": "npx",
      "args": [
        "-y",
        "statecore-mcp"
      ],
      "env": {
        "STATECORE_SCOPE": "your-value",
        "FEATURE_LLM": "your-value",
        "MODEL_API_KEY": "your-value",
        "MODEL_BASE_URL": "your-value",
        "MODEL_NAME": "your-value"
      }
    }
  }
}

Run this in your terminal

claude mcp add statecore --env STATECORE_SCOPE=your-value --env FEATURE_LLM=your-value --env MODEL_API_KEY=your-value --env MODEL_BASE_URL=your-value --env MODEL_NAME=your-value -- npx -y statecore-mcp

Fill in the empty values before running it.

Open in Cursor

Or copy the settings yourself

Paste into .cursor/mcp.json in your project, or ~/.cursor/mcp.json

{
  "mcpServers": {
    "statecore": {
      "command": "npx",
      "args": [
        "-y",
        "statecore-mcp"
      ],
      "env": {
        "STATECORE_SCOPE": "your-value",
        "FEATURE_LLM": "your-value",
        "MODEL_API_KEY": "your-value",
        "MODEL_BASE_URL": "your-value",
        "MODEL_NAME": "your-value"
      }
    }
  }
}

Your browser asks to open the app, then the app shows the settings and asks you to confirm. Key values are left empty for you to fill in.

Open in VS Code

Or copy the settings yourself

Paste into .vscode/mcp.json in your project

{
  "servers": {
    "statecore": {
      "type": "stdio",
      "command": "npx",
      "args": [
        "-y",
        "statecore-mcp"
      ],
      "env": {
        "STATECORE_SCOPE": "your-value",
        "FEATURE_LLM": "your-value",
        "MODEL_API_KEY": "your-value",
        "MODEL_BASE_URL": "your-value",
        "MODEL_NAME": "your-value"
      }
    }
  }
}

Your browser asks to open the app, then the app shows the settings and asks you to confirm. Key values are left empty for you to fill in.

This one runs on your computer, and ChatGPT can only connect to servers on the internet. Pick another app.

Your choice stays on this device in a cookie; no account needed.

Values you fill in

STATECORE_SCOPE env
Override the memory scope name (defaults to the git repository root, else the working directory)
FEATURE_LLM env
Set to 'true' together with MODEL_* variables to enable background distillation of conversational events; everything else works without it
MODEL_API_KEY secret env
OpenAI-compatible API key for background distillation (DeepSeek, OpenAI, Ollama, ...); not required for core memory, audit, and recall
MODEL_BASE_URL env
OpenAI-compatible base URL for the distillation model (e.g. https://api.deepseek.com/v1)
MODEL_NAME env
Model used for background distillation (e.g. deepseek-chat)

These settings are generated from the maker’s registry entry. If the README says otherwise, follow the README.

What it can do

Runs on your computer; the tool list appears in your AI app after you install it.

Basic checksi

We check information anyone can see; we have not read the code. Checks that do not apply are left out of the count. · Checked Nov 7, 2026

✓ Pass
Maker matches the repo
The registry name was verified with the GitHub account yul761, which owns the repo
… Not checked yet
Still maintained
We have not read this repo from GitHub yet
… Not checked yet
Has a licence
We have not read this repo from GitHub yet
– Not applicable
Endpoint responds
This one runs on your computer; there is no internet endpoint
– Not applicable
Sign-in with OAuth
Runs on your computer and uses local settings instead
… Not checked yet
No hidden instructions in tool descriptions
Runs on your computer; we can only read tool lists from internet endpoints

Compared with others in Search & AI memoryi

More stars than 0% of the other 7277 servers in this category
Published to the registry more recently than 30% of the other 7277 servers in this category
Basic checks equal to or better than 100% of the other 7277 servers in this category

Compared with every active server in this category in the registry. Stars count only when the publisher owns the repo.

Common questions

Is Statecore MCP safe?

It passed 1 of 1 applicable basic checks. We have not read the code. Before adding a key or token, see what access the server asks for and use a key with only the permissions you need.

What keys or codes does it need?

You need to fill in: MODEL_API_KEY

Does it run on my computer or in the cloud?

It runs on your computer. Your AI app starts it when needed, and data does not pass through the maker’s servers (unless it calls an online service itself).

Is it still maintained?

The GitHub repo last changed –, and the latest version (0.1.2) reached the registry 3 months ago.

Which apps can use it?

Apps that support MCP, such as Claude Desktop, Claude Code, Cursor and VS Code. You also need Node.js on your computer.

What can I use instead?

In the same category: Context7, Codebase Memory, Exa

Alternatives

Servers in the same category from other makers, sorted by stars.

Reading a card:★ GitHub starsiThree pillars: reviews · checks · usageiUpdated = latest version published to the registryi

Context7

by upstash

Feeds AI the latest docs for libraries and frameworks before it answers, so code it writes does not use outdated, removed functions.

Computer or cloud★ 64,224MITUpdated yesterday

Install

Codebase Memory

by DeusData

Codebase knowledge graph for AI agents — 162 languages, sub-ms queries, 99% fewer tokens.

Runs on your computer★ 48,148MITUpdated 21 days ago

Install

Exa

by exa-labs

Connect AI agents to Exa for web search, content fetching, and multi-step research.

Runs in the cloud★ 5,213MITUpdated last month

Install

README from the maker

Open the README

Copied from the maker’s repo as written. PopNx MCP has not reviewed or endorsed it. HTML, images and scripts are removed. Links lead off this site.

StateCore

Auditable memory for coding agents and AI systems. Every fact StateCore holds carries its evidence, its version chain, and a recorded reason for every discard — so "why do you believe this, and what did you believe before?" always has an answer.

StateCore is a self-hosted, low-drift long-term memory runtime for local or BYO models. It turns memory from accumulated text into governed state: events are ingested, run through a deterministic digest pipeline, and merged into protected stable state. The LLM proposes; the pipeline decides.

Try it in 30 seconds

No server, no signup, no model key — one SQLite file over MCP:

claude mcp add statecore -- npx -y statecore-mcp     # Claude Code

remember a decision in one session, ask why in the next: you get the fact, the evidence behind it, and its version history — superseded and retired facts stay on the record, marked, never deleted. And sessions hand off across vendors: handoff records where one session stopped, and the next one — Claude Code, Codex, Cursor, any MCP client on the same project — receives it at the top of recall, with every earlier stop-point still on the audit chain. Configs for Cursor, dsh, and every other MCP host: apps/mcp/README.md.

Capture is easy. Trust is hard.

Most agent-memory tools compete on capturing more — hook every event, compress the transcript, inject it back. Capture is the solved half of the problem. The unsolved half is what those tools' own issue trackers are full of: memories that silently stop being written, stale decisions injected as if still current, cross-project leakage, and no way to audit or repair what the store believes. That is not a rhetorical claim — docs/prior-art-failure-modes.md cites the verified issues, by number, across five systems.

StateCore is built for that second half:

Nothing is silently lost. Every discard is logged against a fixed set of reasons; every replaced fact keeps a supersededBy chain; retired facts are marked, never deleted.
Nothing is silently believed. Writes go through a deterministic pipeline with consistency gates — an LLM proposal alone cannot promote itself into stable state.
Nothing degrades silently. A failed digest carries degraded; the budget reports what it refused; retrieval reports which embedding stages failed and derives its mode from what actually ran, not from what was configured.
Everything is checkable. why returns a fact's evidence and full version history; a digest's selection report shows exactly what it kept and dropped.

How this compares to other memory systems, mechanism by mechanism: docs/why-auditable.md.

Features

Event store — ingest stream events and keyed documents into per-scope memory
Digest pipeline — background worker consolidates events into stable state through selection, merge, consistency checks, and retry
Protected state — goals, constraints, decisions, and todos are gated by a consistency gate; the LLM proposes, the pipeline enforces
Auditable facts — every fact carries its evidence and its supersession chain, and a fact that leaves the active set is retired rather than deleted, so "why do you believe this, and what did you believe before" stays answerable
Recorded discards — the digest logs what it dropped and why, against a fixed set of reasons; losing information is survivable, losing it silently is not
Replaceable ontology — facets come from a pack resolved per tenant and scope, so the engine stores, protects and supersedes without knowing what a facet means
Retrieval — hybrid keyword + optional pgvector semantic search over events and digests, packed into a caller-declared character budget that reports what it refused; pinned events and write-protected facts get a bounded ranking boost (never a filter), and embedding failures are itemised in retrieval.degraded instead of silently downgrading quality
Reminders — daily reminder job surfaces follow-up items from active scopes
Benchmarks — a published LongMemEval comparison against mem0 OSS at an equal context budget, plus a built-in synthetic regression suite that guards fact retention, goal stability, decision continuity, and retrieval MRR across commits
MCP server — statecore-mcp, a zero-deploy Model Context Protocol front end for coding agents; keyless by default, one SQLite file, no infrastructure

Quickstart

1. Install dependencies

pnpm install

2. Configure environment

cp .env.example .env

Minimum required variables:

PORT=3002

LOCAL_USER_TOKEN=local-dev-user DATABASE_URL=postgresql://postgres:postgres@localhost:5434/statecore REDIS_URL=redis://localhost:6380

To enable LLM features (digest, answers):

FEATURE_LLM=true

MODEL_PROVIDER=openai-compatible MODEL_API_KEY= MODEL_BASE_URL=https://api.openai.com/v1 MODEL_NAME=gpt-5-mini

On OpenAI, pick a model that accepts `reasoning_effort`. The runtime turn

sends it on every request — assistant-runtime.ts defaults it to low rather

than leaving it unset — so POST /v1/memory/runtime/turn fails against a

gpt-4o* model, which rejects the parameter. Digest and answers do not send it

unless MODEL_STRUCTURED_OUTPUT_REASONING_EFFORT is set, so a gpt-4o* model

appears to work right up until the first runtime turn. Any endpoint that

accepts the parameter, or ignores unknown ones, is fine.

3. Start infrastructure

docker compose -f docker-compose.local.yml up -d

This starts Postgres (with pgvector) and Redis.

4. Prepare the database

pnpm db:generate

pnpm db:migrate pnpm seed

5. Start the services

pnpm dev:api      # NestJS API on PORT (default 3002)

pnpm dev:worker # background digest + reminder workers

The API is available at http://localhost:3002 (or whatever PORT is set to).

API

Authentication

All requests require an x-user-id header. For local development, set LOCAL_USER_TOKEN=local-dev-user in .env and send:

x-user-id: local-dev-user

Public surface (`/v1`)

The /v1 prefix exposes the stable, public-facing subset of the API. Full OpenAPI schema:

GET /openapi.json

Interactive Scalar UI:

http://localhost:3002/docs

Reference documentation: docs/api.md

Key endpoints

Method	Path	Description
`POST`	`/v1/memory/events`	Ingest a stream event or document
`POST`	`/v1/memory/retrieve`	Retrieve grounded evidence for a query, within an optional `maxChars` budget
`POST`	`/v1/memory/digest`	Trigger a State Layer digest job
`GET`	`/v1/memory/facts`	Grouped memory facts for a scope
`GET`	`/v1/memory/facts/:factId/provenance`	A fact's evidence and its full version chain
`GET`	`/v1/memory/digests/:digestId/selection`	What a digest kept, and what it discarded and why
`GET`	`/v1/facet-pack`	The active facet ontology for a scope or account
`GET`	`/v1/scopes`	List scopes
`GET`	`/memory/stable-state`	Current stable-state snapshot ¹
`GET`	`/memory/working-state`	Current working-memory snapshot ¹
`GET`	`/memory/layer-status`	Aggregated layer health ¹

The three audit readers in the middle are the ones that make the engine's memory checkable rather than merely stored; docs/api.md lists the full frozen surface.

API stability: the /v1 contract is frozen and additive-only — see

STABILITY.md. It currently covers **22 operations across 20

paths**. The contract carries its own version in the generated OpenAPI document

(info.version, currently 1.8.0), which is what tells you how current a spec

you are holding; it is not the release tag and not any package version.

¹ Internal read-model endpoints — registered only at /memory/..., not under /v1, and not part of the frozen /v1 contract.

Use it from your coding agent (MCP)

statecore-mcp is a separately published npm package that fronts this engine over the Model Context Protocol — no running server required. It runs the engine embedded (one process, one SQLite file), keylessly by default:

npx -y statecore-mcp --data ~/.statecore

Point any MCP client at it, or run it against a full StateCore deployment via --url for shared/multi-agent memory. Full docs, host configs, and the keyless/keyed capability matrix: apps/mcp/README.md.

Client	Setup
Claude Code	`claude mcp add statecore -- npx -y statecore-mcp` (config)
dsh	pinned-executable overlay config included (config)
Cursor	`.cursor/mcp.json` config included (config)
Codex CLI, Gemini CLI, Windsurf, Zed, Cline, OpenCode, Claude Desktop, VS Code Copilot	standard MCP stdio config — `npx -y statecore-mcp` as the command
Anything else that speaks MCP	same stdio command; HTTP via `--url` against a deployment

Team memory: one self-hosted deployment as the shared project brain for every agent your team runs — dsh sessions, Claude Code, CI — with one audit trail across all of them: docs/team-memory.md.

Architecture

apps/api        NestJS HTTP server — ingestion, retrieval, runtime turns, diagnostics

apps/worker BullMQ background workers — digest, working-memory updates, reminders apps/mcp statecore-mcp — MCP server, embedded or thin client against apps/api

packages/core Memory engine (MemoryService, DigestService, RetrieveService, AssistantSession) packages/contracts Zod schemas for all API I/O packages/db Prisma schema, migrations, and client packages/prompts LLM prompt templates (digest, answer, runtime)

StateCore sits between your client and your model endpoint. Events flow in, the digest pipeline consolidates them into protected state, and retrieval pulls grounded evidence back out for answers or runtime turns.

Three-layer memory model:

Fast Layer — synchronous; assembles prompt context for the current turn from recent events, working memory, and stable state
Working Memory — lightweight, quickly-updated structured memory; bridges raw recent turns and slow stable-state consolidation
State Layer — authoritative, replayable, low-drift long-term memory; updated asynchronously through the digest control pipeline

See docs/vision-and-roadmap.md for the layered model design and roadmap.

Testing and Benchmarks

Run package tests:

pnpm --filter @statecore/core test

pnpm --filter @statecore/api test

Run the full latency + memory quality benchmark:

pnpm benchmark

Run the synthetic regression suite (no LLM required):

pnpm --filter @statecore/core eval

The synthetic suite is a regression guard, not a capability benchmark: every scenario scores 1.000 on the current engine, deliberately — its job is t

Only the beginning is shown; read the rest in the repo

Statecore MCP

Overview

PopNx MCP’s three pillars

What you can do with it

Install

Before you install

Values you fill in

What it can do

Basic checksi

Maker matches the repo

Still maintained

Has a licence

Endpoint responds

Sign-in with OAuth

No hidden instructions in tool descriptions

Compared with others in Search & AI memoryi

Common questions

Alternatives

Context7

Codebase Memory

Exa

README from the maker

StateCore

Try it in 30 seconds

Capture is easy. Trust is hard.

Features

Quickstart

1. Install dependencies

2. Configure environment

3. Start infrastructure

4. Prepare the database

5. Start the services

API

Authentication

Public surface (/v1)

Key endpoints

Use it from your coding agent (MCP)

Architecture

Testing and Benchmarks

Public surface (`/v1`)