Contivon — the memory layer for AI applications.
Persistent, identity-scoped memory exposed as a clean API. Sub-50ms recall, hybrid vector + relational storage, provenance on every chunk. Generally available.
contivon.com · public signup
Memory as infrastructure, not a feature you reinvent.
Every AI application needs memory. Most teams build it themselves — stitching together a vector database, an embedding pipeline, an identity layer, a provenance log, and a re-ranker. Six tools, six failure modes, none of it differentiated.
Contivon is that stack, built once, exposed as a single API. Write a memory, recall it later, scoped to an identity, with provenance attached and conflicts resolved. Atlas powers the ranking under the hood.
One API, the whole memory layer
- Ingest, embed, and index in one call.
- Identity-scoped — memory never crosses tenants.
- Hybrid retrieval: vector recall + relational facts.
- Atlas re-ranks every result, with confidence scores.
- Provenance attached to every chunk.
Six primitives that make Contivon production-grade.
Persistent memory API
Durable, structured memory exposed as a clean REST + SDK surface. Store entities, facts, conversations, and outputs once — recall them anywhere.
Sub-50ms recall
Hybrid vector + relational retrieval tuned for production latency. Memory feels like a local cache, not a remote database.
Identity-scoped tenancy
Per-user, per-agent, per-organisation namespaces. Memory never leaks across identities — enforced at the storage boundary.
Provenance + audit
Every chunk carries its source, timestamp, and the identity that wrote it. Required for SOC 2 and regulated deployments.
Conflict resolution
When facts disagree, Contivon surfaces both with confidence scores and lets you resolve via rule, recency, or callback.
First-class SDKs
Node and Python SDKs with typed clients. Webhooks for memory events. Drop-in adapters for LangChain, LlamaIndex, and Vercel AI SDK.
A four-stage pipeline — invisible to your application.
Write once. Recall ranked, scoped, and provenance-attached. The whole pipeline is observable through memory events.
Stage 01
Ingestion
Write memory through a single API. Contivon chunks, embeds, and indexes in the background — synchronous read-after-write within milliseconds.
Stage 02
Hybrid index
Each chunk lands in both a vector store and a relational graph. Recall uses both, ranked by Atlas.
Stage 03
Recall pipeline
Identity-scoped query → hybrid retrieve → Atlas re-rank → provenance attach → JSON response. End-to-end under 50ms at p95.
Stage 04
Memory events
Webhooks fire on write, recall, conflict, and decay. Hook them into your own pipelines for observability and replay.
App ──► Contivon API
│
├── Ingestion ── chunk · embed · index
├── Hybrid Index ── vector store + relational graph
├── Recall ── identity-scoped · Atlas re-ranked
└── Events ── webhooks on write / recall / conflict
│
▼
JSON response ── chunks + provenance + scoresTwo functions. write and recall.
Contivon's API is intentionally small. Most teams ship their first memory-backed feature in an afternoon. SDKs for Node and Python; REST and webhooks for everything else.
import { Contivon } from "@prolixis/contivon";
const memory = new Contivon({ apiKey: process.env.CONTIVON_KEY });
// Write a memory, scoped to a user
await memory.write({
identity: "user_8a2f",
content: "Prefers concise responses. Works in IST.",
tags: ["preference"],
});
// Recall, ranked + provenance attached
const results = await memory.recall({
identity: "user_8a2f",
query: "How should I respond?",
limit: 5,
});Built for AI products that need to remember.
Agents
Long-running agents that remember
Give autonomous agents real memory — past tasks, decisions, user preferences, prior tool calls — without rebuilding context every run.
Chat
Personalised conversational AI
Drop Contivon behind your chat product. Users get a system that remembers them across sessions, devices, and product surfaces.
Workflows
Document and workflow intelligence
Persistent, queryable memory across contracts, tickets, decks, and ops data — without standing up your own vector + storage stack.
Internal AI
Enterprise knowledge layer
Identity-scoped institutional memory for internal copilots. Per-team namespaces, role-based recall, full audit trail.
Contivon isn't a vector database. It's the memory system.
Vector databases
Store embeddings. You build the rest — chunking, identity, conflict, provenance, ranking.
Roll-your-own stack
Six tools stitched together. High maintenance cost, none of it differentiated for your product.
Contivon
The full memory layer as a single API. Identity-scoped, Atlas-ranked, provenance-attached, GA today.
Recall ranked by Atlas Helios.
Contivon uses Atlas's Helios-Mem subsystem to re-rank retrievals, resolve conflicts, and attach confidence. The same engine that powers reasoning across Prolixis products powers your memory layer.
How Atlas worksFrequently asked questions.
What problem does Contivon solve?
Frontier models have no memory. Application teams end up stitching together vector stores, embedding pipelines, and identity logic just to make AI feel persistent. Contivon is that layer — built once, hardened, and exposed as an API.
How is it different from a vector database?
A vector DB stores embeddings. Contivon is a memory system — it ingests, indexes (both vector + relational), enforces identity boundaries, attaches provenance, resolves conflicts, and exposes recall ranked by Atlas. You can build it yourself with five tools, or call one API.
Is Contivon available today?
Yes — Contivon v2.1 is generally available at contivon.com. Public signup is open and SDKs for Node and Python are published.
Where does customer data live?
Each customer gets isolated tenancy. We support multi-region deployments and on-prem / private-cloud installations for regulated environments.
How is Contivon priced?
Usage-based, with a free tier for development. Contact us for enterprise commitments and private deployments.
Contivon — Generally Available
Ship a memory-backed feature this week.
Public signup is open at contivon.com. Free tier for development, usage-based pricing for production, private deployment for regulated environments.