LIVE DEMO → Home Product
Features Use Cases Compare Enterprise
Docs
Documentation Quickstart MCP Server Integrations Benchmark
Pricing Blog DASHBOARD → LOG IN →
File-based Memory Alternative

Kronvex vs File-based Memory:
CLAUDE.md, Obsidian & markdown files

CLAUDE.md is a static config. Obsidian is a note-taking app. Both are clever workarounds — but neither was built to be a memory system. Here's the honest comparison.

Works for 10,000 users — not just 1 dev Semantic search — not keyword match Auto-growing — no manual maintenance 🇪🇺 EU-hosted · GDPR-native

What changes when you use an API instead of files

An honest comparison of how file-based approaches measure up against a proper memory API.

Dimension CLAUDE.md / Obsidian Kronvex
Memory retrieval Full file injected every session Semantic search (top-K by cosine similarity)
Growth Manual edits Auto-stores via API call
Multi-agent No Yes — isolated per agent ID
Multi-user (for products) Impossible Unlimited users via API keys
Search type Keyword / none pgvector cosine similarity
Context cost Always full file (wasted tokens) Only relevant memories
Recency weighting None (all content is equal) Built-in (sigmoid 30d inflection)
Access frequency None Log-scaled frequency scoring
Hosting Local filesystem EU cloud (Frankfurt)
GDPR compliance Manual deletion Built-in erasure, TTL, export
Setup time 30 min (Obsidian) – ongoing (CLAUDE.md) 5 minutes
Scale ceiling 1 developer, 1 project Unlimited agents & users

Why file-based memory breaks down

These are real failure modes — not hypotheticals.

Static file masquerading as memory
CLAUDE.md is read in full every session — there's no search, no filtering, no relevance ranking. A 300-line file injects all 300 lines even when only 5 are relevant. It grows without limit and requires constant manual editing. The moment you close the tab and the knowledge isn't captured, it's lost forever.
No retrieval · Wastes tokens · Single-user only
Personal knowledge manager ≠ Agent memory
Obsidian is an excellent tool for human note-taking. But it requires filesystem access (breaks in cloud/CI), has no semantic search without plugins, doesn't work multi-user, and scales to exactly 1 person × 1 project. The elaborate /resume /compress /preserve workflows are impressive — but they're ops overhead, not a product.
34 sessions → 43 handoff files → manual chaos
Custom memory files always become unmaintainable
Whatever the format — numbered session logs, HANDOFF.md, department-folder vaults — the pattern is the same. It starts clean, accumulates entropy, and requires periodic manual cleanup. The cognitive overhead of maintaining the system approaches the overhead you were trying to eliminate.
Starts simple · Grows into maintenance burden

A proper memory system, not a workaround

Four things Kronvex does that no markdown file can.

Semantic retrieval, not keyword search

Kronvex stores every memory as a 1536-dimension vector embedding. Recall queries the nearest memories by cosine similarity — not keyword match. Ask "what did we decide about auth?" and get the relevant memory even if it says "JWT with 15min TTL, not session tokens".

pgvector · cosine similarity · text-embedding-3-small

Confidence scoring: recency + frequency

Every recalled memory is ranked by confidence = similarity × 0.6 + recency × 0.2 + frequency × 0.2. Recency uses a sigmoid with a 30-day inflection point. Frequently-accessed memories rank higher. Old, unused memories fade gracefully — no manual archival.

similarity · recency · frequency
🚀

Ships as a product, not a personal workflow

Your CLAUDE.md works for you. Kronvex works for your users. Isolate memory per user with agent IDs, enforce quotas with API keys, run 10,000 users concurrently. The same 3 endpoints that power your dev workflow can power a multi-tenant SaaS product.

multi-tenant · REST · isolated agents
🇪🇺

EU-hosted, GDPR-native

All data stored in Supabase Frankfurt. Right to erasure is a first-class API endpoint — not a database migration you write when a user files a GDPR request. TTL-based memory expiry, data export, and DPA available.

Frankfurt · right to erasure · TTL · DPA

File-based vs API: what the code looks like

One approach requires you to be the memory system. The other does it for you.

CLAUDE.md approach Manual
# Add to CLAUDE.md manually:
# - User prefers Python
# - We use PostgreSQL
# - Auth uses JWT (15min TTL)
# - Component style: functional React
# [continues for 250 more lines...]

# Every session: full file injected
# No search. No relevance ranking.
# You edit it. You maintain it. You archive it.
Python · httpx Kronvex API
import httpx

# Store once, retrieve forever
httpx.post(
    "https://api.kronvex.io/api/v1/agents/my-agent/remember",
    headers={"X-API-Key": "kv-..."},
    json={"content": "Auth uses JWT with 15min TTL. Refresh is silent."}
)

# Semantic recall — only what's relevant
ctx = httpx.post(
    "https://api.kronvex.io/api/v1/agents/my-agent/inject-context",
    headers={"X-API-Key": "kv-..."},
    json={"query": "authentication setup", "max_tokens": 600}
).json()["context"]
# Returns only the 3 most relevant memories

Migrating from CLAUDE.md to Kronvex: 10 minutes

Three steps. The last one is the satisfying part.

1

Get your free API key

Create an account at kronvex.io/demo — you get 100 memories, 1 agent, no credit card required. Your kv-... key is ready in seconds.

2

Run the migration script

Parse your CLAUDE.md into logical chunks (one fact or rule per memory), then POST each to /api/v1/agents/{id}/remember. A simple Python loop over split paragraphs is all it takes. Contact hello@kronvex.io and we'll send you a ready-to-run script.

3

Slim down your CLAUDE.md to 5 lines

Replace your entire CLAUDE.md with just: the Kronvex API key reference, the agent ID, and the 3 endpoint calls. Everything else is now in the API — searchable, auto-ranked, and never injected unless relevant.

Your questions, answered

Yes — a minimal CLAUDE.md that bootstraps the API connection works perfectly. Store everything significant in Kronvex; leave only the API key and agent ID in CLAUDE.md. This is actually the recommended setup: CLAUDE.md becomes a 5-line config file, not a growing knowledge dump.
MCP plugins for Obsidian give you file read/write access — still local filesystem, still single-user, still manual maintenance. The Kronvex MCP server does the same thing but with cloud-backed semantic memory: no vault to sync, no filesystem dependency, works in CI/CD and cloud environments.
Yes — set up a MCP server in 10 minutes (see /blog-mcp-memory) or call the REST API directly from CLAUDE.md hooks. For Claude Code, the typical pattern is: CLAUDE.md bootstraps the connection, and a pre-session hook calls inject-context to prime the context with only the relevant memories for that task.

Related resources

Ready to replace your markdown files?

Start free — first memory in under 5 minutes

No credit card. No SDK. Just an API key and three endpoints. Migrate your CLAUDE.md content in one script.

Get your free API key →