Home · Memory & Data

plate · lexicon · galley

Memory that learns, context that fits

The plate memory plane extracts facts, consolidates them while idle, and serves hybrid recall — while context compaction and a promotion ladder keep long runs inside the window. Knowledge lives in a graph you can query with SPARQL, on the database you already run.

Engraved archival memory system persisting, linking, consolidating, and retrieving a compact bundle of records

DURABLE MEMORYTENANT-SCOPED · GALLEY-BACKED

ObserveThe forme loop emits typed events, facts, links, and explicit memory actions.

Persist in GalleySQLite or a shared SQL backend records durable state with migrations.

Consolidate in PlateExtraction, deduplication, graph links, and background consolidation refine recall.

Retrieve + compactHybrid search selects relevant memory while compaction respects the token window.

Durability is mechanical; extraction and ranking quality remain model- and embedding-dependent and should be evaluated on your corpus.

plate — cognitive memory

Extract, consolidate, recall

Layered storesone plane

Memory is not one bucket. The plate holds working memory of recent turns, dense vector embeddings, extracted semantic triples, resolved entities, and an ontology layer — queried together.

Hybrid recallBM25 + vector

Recall fuses keyword (BM25) and semantic vector search, partitioned by tenant and actor so memory never leaks across principals. A native sqlite-vec backend is used when the extension is available.

Dreamingbackground consolidation

Scheduled background passes consolidate working memory into long-term storage — scoring facts by importance and freshness, detecting contradictions across sessions, and marking stale facts as their sources change.

Context & Token Optimization

Fit more into every window

Long agent runs blow past context windows and burn tokens. Jikji treats the window as a resource to be managed, not a wall to hit.

Context compaction

Older, low-importance turns are evicted by an importance score before the window overflows, so the thread keeps what matters while the token count stays bounded — compaction is triggered as a run approaches its limit.

Model-promotion ladder

When a turn would overflow, the run retries on the next larger context window and stays promoted — instead of failing or silently truncating the prompt.

Hot-path & prompt caching

A bounded in-process memo caches hot recomputation, a tenant-namespaced cache serves cross-request results, and provider-native prompt caching (cache-control, cache keys) is used where available.

A separate embedding path

Recall and re-ranking run on their own embedding path — pick the model you want (Jina, OpenAI, or Ollama), kept independent from the chat provider so retrieval is tuned on its own. It's opt-in: with no embedding provider set, the system runs graph- and keyword-only.

Semantic response caching reuses answers by meaning, not exact text:

typebackbone:
  response_cache:
    enabled: true
    embedding_model: jina-embeddings-v3
    similarity_threshold: 0.86
    ttl: 1h

lexicon — knowledge & ontology

A knowledge graph you can query

Build from documentslexicon

The lexicon extracts entities and relationships from documents into a knowledge graph, resolves contradictions by policy, and re-ranks retrieved facts by semantic similarity. A guidance engine injects deterministic FOLLOW patterns or learns new ADAPT directives.

SPARQL 1.1native RDF

An embedded RDF triple store with TTL parsing answers SPARQL 1.1 SELECT queries — basic graph patterns, FILTER, OPTIONAL, UNION, MINUS, BIND, VALUES, property paths, sub-selects, and aggregation with GROUP BY and HAVING — with bounded result safety.

Semantic re-rankingrelevance

Catalog-loaded ontologies, tenant scoping, and semantic re-ranking let retrieval lean on structured meaning rather than keyword overlap alone.

Query the knowledge graph with SPARQL 1.1:

PREFIX org: <http://example.org/>
SELECT ?service ?owner WHERE {
  ?service a org:Service ;
           org:owner ?owner ;
           org:tier  "critical" .
}
ORDER BY ?service

Portable knowledge interchange

OKF in; lexicon and RDF out

Jikji bridges the Open Knowledge Format (markdown plus YAML frontmatter) into its native lexicon graph and RDF/TTL pipeline, while preserving a portable bundle that other systems can read.

Lossless round-trip

The native okf.load and okf.export tools round-trip the checked-in Markdown and YAML-frontmatter sample with deterministic identities, confined paths, and a portable reference-adapter check.

Typed and auditable

Portable OKF links remain readable markdown; Jikji adds typed relations, confidence, evidence quotes, provenance, and queryable graph records without locking the source into a proprietary format.

OKF ↔ lexicon ↔ TTL contract and flow ↑

galley — storage

The database you already run

All durable state — memory, runs, tasks, marketplace, credentials, audit — lives in one explicit, migrated schema behind the galley workspace.

SQLite	The default — embedded, zero-setup durable state for desktop and single-node deployments, with WAL mode and busy-retry handling.
PostgreSQL	Shared-database runtime for multi-node high availability, with dialect-aware migrations and a distributed lease manager for task recovery.
MySQL	A second shared-database option for multi-node HA, behind the same schema and migration path.
sqlite-vec	A native vector backend wired into the recall path, used when the sqlite-vec extension is present.

Sessions are first-class data. The session library lists, continues, renames, and deletes conversations — and forks one at any message into a new branch, with full fork-tree views, so you can explore alternatives without losing the original thread.

← Back

Orchestration

Ontology