Does memspine work with any LLM or agent framework?

Yes. memspine is a plain HTTP API with Bearer-token auth — any agent that can make an HTTP request can append and search memory. SDKs ship for Rust, Python, and TypeScript.

Can I self-host memspine?

Yes. One command installs a single Rust binary with no dependencies: curl -fsSL https://memspine.com/install.sh | sh. Each tenant's data lives in its own FFS database file on your disk.

How does multi-tenancy work?

Every tenant gets a dedicated FFS database file, per-tenant rate limits, and scoped API keys (read / write / admin). There is no shared table, so one tenant's load never sits in another's query path.

Codestin Search App

Q: What is agent memory?

Agent memory is the durable record of tool calls, decisions, retrieval traces, and derived facts. memspine stores those events as a typed graph with embeddings so agents can recall prior events and trace where a fact came from.

Q: How is memspine different from a vector database?

A vector database answers one question: what's similar. Agent memory also needs what happened (typed events in order) and where did this come from (provenance edges). memspine stores all three in one engine — vector index, event graph, and Cypher traversal — instead of bolting a vector store onto a separate event log.

A vector hit is not memory.

memspine keeps the append log, vector index, and provenance graph in the same tenant-owned file set, so recall can answer what matched and where it came from.

Quickstart

One binary. Local files.

The installer puts memspine-server and memspine-admin in ~/.local/bin. Linux x86_64 and macOS arm64 builds are checksum-verified and run without root.

~/fleet — memspine

$ curl -fsSL https://memspine.com/install.sh | sh
Checksum OK.
Installed memspine-server and memspine-admin to ~/.local/bin

$ MEMSPINE_BIND=0.0.0.0:7777 memspine-server &
$ curl localhost:7777/health
{"status":"ok","service":"memspine-server","version":"0.0.0"}

append → provenance

# embeddings default to 384 dims; pin to 4 for this walkthrough
$ MEMSPINE_EMBEDDING_DIM=4 memspine-server

$ curl -X POST localhost:7777/v1/memory/event \
  -H "Authorization: Bearer 00000000-0000-0000-0000-000000000042" \
  -H "Content-Type: application/json" \
  -d '{"kind":"tool_call","embedding":[0.1,0.2,0.3,0.4],
       "properties":{"name":"web.fetch","url":"https://example.com"}}'

$ curl -X POST localhost:7777/v1/memory/cypher \
  -H "Authorization: Bearer 00000000-0000-0000-0000-000000000042" \
  -H "Content-Type: application/json" \
  -d '{"query":"MATCH (n:Event)-[:SOURCE_FROM]->(m:Event) RETURN count(n)"}'

API

Routes carry scopes.

Auth is Authorization: Bearer <key>. Every handler checks the resolved tenant and the key scope. Writes accept Idempotency-Key; SDKs ship for Rust, Python, and TypeScript.

GET /health

Liveness probe for the data-plane listener.

GET /metrics

Prometheus exposition with per-tenant series.

GET /v1/whoamiread

Return the tenant resolved from the bearer key.

POST /v1/memory/eventwrite

Append a typed event plus optional embedding.

POST /v1/memory/searchread

Search HNSW vectors with an optional Cypher predicate.

POST /v1/memory/cypherread

Traverse events and SOURCE_FROM edges.

POST /v1/admin/tenantsadmin

Create a tenant in the control plane.

POST /v1/admin/keysadmin

Mint a scoped key, with plaintext returned once.

Architecture

One warm file set per tenant.

FFS handles pages, WAL, MVCC, HNSW, and atomic graph/vector commits. memspine wraps it in the service layer an agent fleet needs.

That layer is tenancy, key scopes, rate limits, quotas, metrics, trace ids, and an admin audit log.

HTTPaxum + tower-http for tracing and CORS

AuthBearer token to tenant, scope check per handler

Coreper-tenant pool for append, HNSW search, Cypher, provenance

FFS.ffs, .wal, .hnsw, and .rels files per tenant

Operations

Trace the request you just made.

Every response carries a trace id. Metrics are per tenant. Token buckets isolate runaway callers. Admin changes append to an audit log.

Tracing

Every response carries x-memspine-trace-id, caller-supplied or generated, and the same id is on every span.

Metrics

/metrics exposes write rate, query latency, storage growth, and vector-index churn per tenant.

Rate limits

Per-tenant token buckets keep a runaway agent from taking down its neighbours or silently burning capacity.

Audit

Admin actions append to an immutable log, paginated over the API.

FAQ

Questions operators ask.

Agent memory is not just semantic similarity. It is a durable event graph with enough context for recall, debugging, and source tracing.

What is agent memory?

The durable record of tool calls, decisions, retrieval traces, and derived facts.

How is memspine different from a vector database?

A vector database answers what is similar. Agent memory also needs what happened and where it came from.

Does it work with any LLM or agent framework?

Yes. It is a plain HTTP API with Bearer-token auth. Anything that can make an HTTP request can append and search memory.

Can I self-host it?

Yes. One command installs a single Rust binary with no dependencies. Each tenant's data lives in its own FFS file.

Status

v0 surface, narrow promises.

The HTTP surface, scopes, rate limits, admin plane, audit log, vector search, edge traversal, and FFS storage path work end to end, gated by CI on every push. The v0 executor returns node ids and counts; richer Cypher projections arrive with the FFS columnar read path. Running an agent fleet and want memory under it? Get in touch via erp.ai.

Agent memory in tenant files.