MCP 服务器

Kremis

MCP server exposing a deterministic, local knowledge graph over stdio. Zero LLM calls in the bridge; answers are classified as Fact, Inference, or Unknown and persisted in redb (ACID, BLAKE3-hashed).

README

<h1 align="center">Kremis</h1>

A deterministic knowledge graph MCP server. Local, single binary, no LLM in the loop.

A minimal, graph-based cognitive substrate in Rust. Records, associates, retrieves — but never invents.

Alpha — Functional and tested. Breaking changes may still occur before v1.0.

Why Kremis

Problem	How Kremis addresses it
Hallucination	Every result traces back to a real ingested signal. Missing data returns explicit "not found" — never fabricated
Opacity	Fully inspectable graph state. No hidden layers, no black box
Lack of grounding	Zero pre-loaded knowledge. All structure emerges from real signals, not assumptions
Non-determinism	Same input, same output. No randomness, no floating-point arithmetic in core
Data loss	ACID transactions via `redb` embedded database. Crash-safe by design

Design Philosophy — why these constraints exist.

Features

Deterministic graph engine — Pure Rust, no async in core, no floating-point. Same input always produces the same output
CLI + HTTP API + MCP bridge — Three interfaces to the same engine: terminal, REST, and AI assistants
BLAKE3 hashing — Cryptographic hash of the full graph state for integrity verification at any point
Canonical export (KREX) — Deterministic binary snapshot for provenance, audit trails, and reproducibility
Zero baked-in knowledge — Kremis starts empty. Every node comes from a real signal
ACID persistence — Default redb backend with crash-safe transactions

Use Cases

AI agent memory via MCP

Give Claude, Cursor, or any MCP-compatible assistant a verifiable memory layer. Kremis stores facts as graph nodes — the agent queries them, and every answer traces back to a real data point. No embeddings, no probabilistic retrieval.

LLM fact-checking

Ingest your data, let an LLM generate claims, then validate each claim against the graph. Kremis labels every statement as [FACT] or [NOT IN GRAPH] — no confidence scores, no ambiguity.

Provenance and audit trail

Export the full graph as a deterministic binary snapshot, compute its BLAKE3 hash, and verify integrity at any point. Every node links to the signal that created it. Useful for compliance workflows where you need to prove what data was present and when.

Honesty Demo

Ingest a few facts, let an LLM generate claims, and Kremis validates each one:

[FACT]          Alice is an engineer.              ← Kremis: "engineer"
[FACT]          Alice works on the Kremis project. ← Kremis: "Kremis"
[FACT]          Alice knows Bob.                   ← Kremis: "Bob"
[NOT IN GRAPH]  Alice holds a PhD from MIT.        ← Kremis: None
[NOT IN GRAPH]  Alice previously worked at DeepMind. ← Kremis: None
[NOT IN GRAPH]  Alice manages a team of 8.         ← Kremis: None

Confirmed by graph: 3/6
Not in graph:       3/6

Three facts grounded. Three fabricated. No ambiguity.

python examples/demo_honesty.py            # mock LLM (no external deps)
python examples/demo_honesty.py --ollama   # real LLM via Ollama

Quick Start

Requires Rust 1.89+ and Cargo.

git clone https://github.com/TyKolt/kremis.git
cd kremis
cargo build --release
cargo test --workspace

cargo run -p kremis -- init                                          # initialize database
cargo run -p kremis -- ingest -f examples/sample_signals.json -t json # ingest sample data
cargo run -p kremis -- server                                        # start HTTP server

In a second terminal:

curl http://localhost:8080/health
curl -X POST http://localhost:8080/query \
  -H "Content-Type: application/json" \
  -d '{"type":"lookup","entity_id":1}'

Note: CLI commands and the HTTP server cannot run simultaneously (redb holds an exclusive lock). Stop the server before using CLI commands.

Docker

docker build -t kremis .

# MCP server (default) — pipe MCP stdio JSON-RPC; suitable for any MCP client
docker run -i --rm kremis

# HTTP API only — override the entrypoint
docker run -d -p 8080:8080 -v kremis-data:/data \
  --entrypoint kremis kremis server -H 0.0.0.0 -D /data/kremis.db

Architecture

Component	Description
kremis-core	Deterministic graph engine (pure Rust, no async)
apps/kremis	HTTP server + CLI (tokio, axum, clap)
apps/kremis-mcp	MCP server bridge for AI assistants (rmcp, stdio)

See the architecture docs for internals: data flow, storage backends, algorithms, export formats.

Documentation

Full reference at kremis.mintlify.app:

Topic	Link
Introduction	kremis.mintlify.app/introduction
Installation	kremis.mintlify.app/installation
Quick Start	kremis.mintlify.app/quickstart
Configuration	kremis.mintlify.app/configuration
CLI Reference	kremis.mintlify.app/cli/overview
API Reference	kremis.mintlify.app/api/overview
MCP Server	kremis.mintlify.app/mcp/overview
Philosophy	kremis.mintlify.app/philosophy

Testing

cargo test --workspace
cargo clippy --all-targets --all-features -- -D warnings
cargo fmt --all -- --check

Benchmarks

Auto-generated on CI runners — 2026-05-10.

Operation	Linux	Windows	macOS
Node insertion (100K)	20.97 ms	18.89 ms	17.31 ms
Signal ingestion (10K batch)	7.23 ms	8.42 ms	9.54 ms
Graph traversal (depth 50, 1K nodes)	2.6 µs	3.3 µs	2.0 µs
Strongest path (1K nodes)	7.5 µs	8.9 µs	5.8 µs
Canonical export (1K nodes)	68.2 µs	76.4 µs	52.0 µs
Canonical import (10K nodes)	3.09 ms	3.59 ms	3.17 ms
Redb node insertion (1K)	367.17 ms	9.5 s	345.79 ms
<!-- BENCHMARK-END -->