-
Notifications
You must be signed in to change notification settings - Fork 0
Home
Welcome to the SERAPH wiki!
Its origins extend from knowledge graphs and vector databases, architecting components together to realize bounded propagation retrieval for agents, in order to provide a common memory substrate that is agnostic to use case. Many of you may have done the same thing, and have run into the same issues with that methodology. Constantly having to adjust taxonomy and the ontology of the system to fit different operating modes. Existing memory systems for AI agents make a structural compromise: the 'vector space' (where semantic similarity lives) and the 'graph' (where traversal lives) are separate layers that must be kept in sync. Vector stores answer "what is similar?" Graph databases answer "what is connected?" You query one to get candidates, then traverse the other for context. The seam between them is operational overhead, consistency risk, and a conceptual mismatch
SERAPH collapses this, the vector space IS the graph, semantic similarity and structural traversal become the same operation at different resolutions. Topology is created from content not declared (declared edges are supported, but not required) more on this later.
SERAPH is a append only storage layer, that may give one pause, as it did me adopting it as a architectural invariant but it provides several key advantages that make it invaluable to the realization of a attestable, verifiable, honest substate of knowledge. During initial design, as I said the goal was a agent memory substrate, it occurred to me, unlike my previous escapades where I was bounding propagation, confidence and retrieval by temporal factors, that a AI memory system shouldn't adopt the lossy, fragmented natures of the human concept of memory. It should have the ability to describe all conditions applicable to the specific moment of knowledge acquisition, thereby providing the proof of the knowledge, what makes it important and how its understanding evolved from that acquisition honestly.
These qualities make SERAPH an ideal substrate for a memory layer vs bolting together disjoint systems.
Content is not categorized or assigned to a predefined taxonomy. As content arrives, SERAPH places each item adjacent to those it resembles, in whatever dimension the encoder operates on. The overall shape emerges from the content itself, and may be nudged through operator-supplied seeds and SERAPH's authoring tools; what is foreclosed is the imposition of a schema separate from the content that would justify it.
Applications may declare any relationships their domain requires. SERAPH tracks these precisely, with support for directionality, retraction, and bidirectional edges. These declared edges constitute an overlay; they do not distort the emergent layer beneath. Intuitive similarity remains intact, and declared structure remains explicit. Most systems force a choice between the two. SERAPH supports both within the same store, with a clear boundary between them.
Multi-step reasoning is a first-class operation in SERAPH. A pipeline might find content by similarity, follow a declared relationship, expand into similar items, and then filter by another relationship. These pipelines are declarative, composable, and deterministic: the same store and the same query always produce the same result, in the same order, with the same scoring. This level of determinism is uncommon in systems that combine similarity and structure, and it is what makes SERAPH suitable as a substrate for serious reasoning.
SERAPH does not assume that content is text, nor that it is language at all. Provided with any encoder that produces normalized vectors, the same substrate organizes images, audio, code, molecules, behavioral traces, or any other content with a similarity structure. Capabilities travel with the substrate rather than with the modality.
Other knowledge systems treat similarity as a fixed property of the embedding model: two items are either close in the model's vocabulary or they are not. SERAPH exposes the embedding manifold as a workable space. A query may be biased toward one region, away from another, or projected along a chosen direction, as a runtime geometric operation on the manifold itself, with no additional learned components and no separate re-ranking model. At gentle magnitudes the warp routes results within their natural neighborhood; at larger magnitudes the same operation recovers structural and relational similarity that the encoder's raw vocabulary does not express on its own, retrieving content that plays the same role as the target rather than content that shares its surface vocabulary. Cross-domain analogy — finding the legal analog of an engineering failure, the molecular analog of an organizational pattern, the behavioral analog of a known fraud signature — becomes a deterministic geometric operation rather than a stochastic prompt to a separate reasoner. Other architectures approximate this capability only with substantial additional machinery: multi-vector indices for structural retrieval, authored knowledge-graph mappings for analogical traversal, or language models invoked as opaque re-rankers. SERAPH performs the same work on the substrate that is already in place, with results that are deterministic, inspectable, and reproducible.
The substrate exposes three traversal operations over the same content: a lineage walk over the parent tree (the structural record of how content arrived), a similarity walk over the embedding field (the only operation that crosses subtree boundaries), and a relation walk over declared edges. All three compose within a single query. Following a declared relationship and finding a similar item are operations of the same kind. A query can move from a piece of content into its neighbors, into its declared relations, into the neighbors of those relations, and back again, in one continuous expression.
Once recorded, every piece of content is recorded permanently. New information extends the chain; it does not overwrite prior records. When duplicates require consolidation, SERAPH leaves a forwarding marker so historical references remain valid. Even the retraction of a declared relationship is itself a recorded event rather than a deletion. The full history of what was learned and what was claimed remains recoverable at any time.
Each record is cryptographically chained to its predecessor, attribution to a licensed creator. The genesis record encodes the creator's identity into the chain's root, and every subsequent committed record carries an Ed25519 signature over its content commitment. Any modification, whether to content, ordering, declared relationships, or attribution, visibly breaks the chain at verification time. The memory itself constitutes the audit trail, and every record in that trail names the party responsible for it.
SERAPH does not require a database server, a separate vector index, network calls, or a language model invoked from within the substrate. Ingesting new content or embedding a new query requires the chosen encoder. Every other operation, including opening a store, verifying its integrity, traversing its structure, and following declared relationships, requires only the SERAPH engine and the file itself. Any intelligent system that uses SERAPH operates cleanly above it and can be replaced without disturbing the underlying memory.
A SERAPH store is a single file. It can be transmitted by email, signed, notarized, archived, or transferred to a third party who has never previously seen it. That third party can open the file and verify its contents without access to any other system.
Most knowledge systems maintain three separate dimensions: what is known, when it was learned, and where it is stored. These dimensions are connected by abstraction layers that keep each one independently controllable. A relational database has tables (knowledge), insertion order (time), and memory layout (space), and the three are independent by design. Rows can be reordered without changing facts. The storage engine can be swapped without touching the schema. Indices can be added without accumulating history. These separations exist for sound engineering reasons, but they have a cost: the dimensions cease to correlate with each other. The database does not know that one row was inserted after another in any sense that affects what either row means. Insertion order is metadata, not substance.
In SERAPH, insertion order is substance. The three dimensions are not coordinated; they are identical.
Knowledge is curvature. A frame's meaning is its position in the embedding manifold. The content string is what carried it there through the encoder, but the knowledge is the location. When adjacent content arrives it lands nearby, and its parent edge creates a local gradient that pulls the region tighter. Enough accumulation and the region becomes an eigenframe basin: a stable attractor that subsequent queries fall into. Learning is the accumulation of curvature. Understanding a topic is having enough curvature in its region that new queries resolve to it without external guidance.
Time is the order in which curvature accumulated. Every frame carries a timestamp, and every eigenframe became one at a specific moment: the ingest that pushed its in-degree across the promotion threshold. The topology at any moment is a function of every ingest up to that moment. The parent each frame was committed under depends on the state of the manifold at the instant of commit, which depends on every prior ingest, which determines the frame's watermark, which constrains every descendant. Reordering the ingests does not produce a different log of the same store; it produces a different manifold entirely. Time is load-bearing structure, not metadata about the structure.
Knowledge has no existence separate from the spatial configuration that accumulated through time. There is no facts table that the geometry indexes. There is no hidden semantic layer behind the vectors. The vectors, their positions, their connections, and their accumulated in-degrees are what the system knows. Delete the graph and keep the raw frames, and the knowledge is lost: not because the facts disappear but because their relationships do, and in a geometric substrate relationships are what meaning consists of. The graph is the knowledge; the graph is a spatial configuration; the spatial configuration is a temporal deposit. Three descriptions, one thing.
Ontology and epistemology collapse into a single operation. What exists, how it came to be known, and what it means are not three questions requiring three different kinds of answer. Where a frame sits tells you what it means. How it got there tells you what justifies it. What surrounds it tells you what it implies. The same retrieval operation answers all three because they are not separate questions; they are the same question asked with different emphasis.
Space is equally load-bearing. The manifold cannot be compressed by moving frames closer together without losing meaning, because the distances between frames are the meaning. The manifold cannot be reorganized by imposing categories, because any imposed category is a lossy projection of the underlying continuous geometry. The space is not a container for knowledge. The space is the knowledge's shape, and the shape is the answer to every query that can be asked of it.
This is why SERAPH's small mechanical surface is not minimalism for its own sake. Every abstraction layer that other systems add, for sound engineering reasons, is a layer that separates time from space from knowledge and erases the identity between them. SERAPH was designed at the level where the three are already the same thing, and refused to add the layers that would separate them again.
The convergence is not three forces meeting at a point. It is one substance viewed through three windows. The substrate was latent in the mathematics of metric spaces and contrastive embeddings; SERAPH is what it looks like when the identity is acknowledged rather than buried under abstractions.