Knowledge Architecture
Three-layer knowledge system powering Fixie AI agents: Letta Archives, Graphiti temporal graph, and per-agent memory
Status: Production | Framework: Letta v0.16.6 | Graphiti: zepai/knowledge-graph-mcp | Agent Type: letta_v1_agent
Fixie AI agents operate on a three-layer knowledge system. Each layer serves a different purpose, update frequency, and scope. Together they give agents access to static documentation, temporal conversational facts, and personal memory -- all isolated by membership and tier.
Overview
Three Knowledge Layers
| Layer | Technology | Content | Scope | Update Frequency |
|---|---|---|---|---|
| Network Knowledge | Letta Archives | Brand, tokenomics, compliance, architecture docs | Shared across all agents | Manual ingestion when docs change |
| Temporal Knowledge | Graphiti (MCP) | Facts extracted from conversations, entity relationships | Isolated by group_id | Automatic during conversations |
| Agent Memory | Letta Core Memory | Persona, human context, preferences | Per-agent instance | Updated every conversation |
Three Knowledge Layers:
+------------------------------------------------------------------+
| LETTA SERVER (v0.16.6) |
| |
| LAYER 3: Agent Memory LAYER 1: Letta Archives |
| (per-agent, in-context) (shared, searchable) |
| |
| +------------------+ +---------------------------+ |
| | persona | | fxyz-network | |
| | human | | brand, tokenomics, arch | |
| | context | | fxyz-compliance | |
| | preferences | | MiCA, VASP, regs | |
| +------------------+ | fxyz-market | |
| | FX theory, math models | |
| LAYER 2: Graphiti (MCP) | fxyz-graph | |
| (temporal, conversational) | Cypher, schema, ontology| |
| +---------------------------+ |
| +---------------------------+ |
| | search_facts | |
| | search_nodes | |
| | add_episode | |
| | get_episodes | |
| +------------+--------------+ |
+---------------|---------------------------------------------------+
| streamable_http (MCP)
v
+------------------------------------------------------------------+
| GRAPHITI SERVICE (zepai/knowledge-graph-mcp) |
| |
| graphiti-core: entity extraction, temporal edges, deduplication |
| group_id isolation: shared:network | member:{id} | circle:{id} |
| |
| Connects to: FalkorDB (internal graph store, NOT fxyz Neo4j) |
| LLM: Claude Haiku (entity extraction) |
| Embeddings: openai/text-embedding-3-small (1536 dim) |
+------------------------------------------------------------------+
|
v
+------------------------------------------------------------------+
| FALKORDB (Graphiti-internal) |
| |
| Graphiti nodes: :Entity, :EpisodicNode, :CommunityNode |
| Isolation: group_id property on all Graphiti nodes |
| NOTE: This is Graphiti's own graph DB, separate from fxyz Neo4j |
+------------------------------------------------------------------+Layer 1: Letta Archives (Static Shared Knowledge)
Archives are collections of chunked document passages stored in Letta and attached to agents at creation time. They provide the baseline knowledge every agent needs.
Archive Definitions
| Archive | Content | Attached To |
|---|---|---|
fxyz-network | Brand codex, tokenomics v4.1, founding philosophy, architecture overview | All agents |
fxyz-compliance | MiCA VASP requirements, regulatory frameworks, jurisdictions | All agents |
fxyz-market | FX theory, mathematical models, market analysis patterns | market_analysis persona agents |
fxyz-graph | Neo4j schema, Cypher patterns, ontology docs, knowledge graph structure | query_builder persona agents |
How Archives Work
- Archives are created via
POST /api/fixie/archives(admin, idempotent) - Documents are ingested via
POST /api/fixie/archives/ingestwith chunking (1500 chars, 200 overlap) - Agents search archives using
archival_memory_search(built-in Letta tool) - Network + compliance archives are attached to every agent at creation
- Type-specific archives are attached based on
personaType
Agent Access
- Agents query archives with
archival_memory_search({ query: "..." }) - Passages are returned ranked by semantic similarity
- Premium agents can also write with
archival_memory_insertfor personal archival storage
Layer 2: Graphiti (Temporal Conversational Knowledge)
Graphiti provides what static archives cannot: entity extraction, temporal validity, cross-referencing, and deduplication of knowledge learned from conversations.
What Graphiti Does
| Capability | Description |
|---|---|
| Entity Extraction | LLM-driven extraction of entities and relationships from conversation text |
| Temporal Edges | Facts have tValid / tInvalid timestamps -- knowledge can expire or be superseded |
| Deduplication | Same entity mentioned differently across conversations gets merged (0.85 cosine threshold) |
| Group Isolation | group_id property on every node ensures tenant isolation within shared Neo4j |
Deployment
Graphiti runs as a standalone container (zepai/knowledge-graph-mcp:latest) registered with Letta as a streamable_http MCP server. Internally, Graphiti uses FalkorDB as its graph store -- this is completely separate from the fxyz Neo4j instance. Graphiti labels (:Entity, :EpisodicNode, :CommunityNode) live in FalkorDB, not in the domain graph.
# docker-compose.graphiti.yaml
services:
graphiti:
image: zepai/knowledge-graph-mcp:latest
container_name: graphiti-mcp
hostname: graphiti-server
environment:
MODEL_NAME: claude-haiku-4-5 # entity extraction (cheap, fast)
EMBEDDING_MODEL: openai/text-embedding-3-small
EMBEDDING_DIM: "1536"
OPENAI_API_KEY: ${OPENAI_API_KEY}
ports:
- "8199:8199"
# Graphiti uses FalkorDB internally (bundled or sidecar),
# NOT the fxyz Neo4j instanceMCP registration is done via POST /api/fixie/mcp (admin, idempotent). Graphiti is registered as a streamable_http transport.
Group-Based Isolation
| Group ID Pattern | Scope | Used By |
|---|---|---|
shared:network | Network-wide facts from Florin/Cypher/Sentinel conversations | Network agents |
fixie:member:{memberId} | Personal facts from member agent conversations | Member agents |
fixie:project:{projectId} | Project-scoped knowledge (future) | Project agents |
Graphiti Tools
| Tool | Description |
|---|---|
search_facts | Search temporal facts in the knowledge graph |
search_nodes | Search entity nodes in the knowledge graph |
add_episode | Add a conversation episode for entity extraction |
get_episodes | Get recent episodes from the graph |
All tiers have access to all Graphiti tools. Tier differentiation is based on model quality (Haiku / Sonnet / Opus), not tool access.
FalkorDB Graph Isolation
Graphiti uses FalkorDB as its internal graph store, completely separate from the fxyz Neo4j domain graph. Graphiti's labels live in FalkorDB:
| Graphiti Label | Purpose |
|---|---|
:Entity | Extracted semantic entities (people, concepts, preferences) |
:EpisodicNode | Raw episode/message storage |
:CommunityNode | Entity clusters |
Tenant isolation is enforced by group_id property on all Graphiti nodes within FalkorDB.
Layer 3: Agent Memory (Per-Agent Blocks)
Each Fixie agent has in-context memory blocks that are always available to the LLM without requiring a tool call.
Memory Blocks by Tier
| Block | Free | Standard | Premium | Description |
|---|---|---|---|---|
persona | Yes | Yes | Yes | Agent identity, domain, tool guidance, behavioral rules |
human | Yes | Yes | Yes | Member context (DID, owner ID, memory group) |
context | -- | Yes | Yes | Member's graph neighborhood (contribution level, circles, roles, wallet) |
preferences | -- | -- | Yes | Learned interaction patterns and preferences |
The context block is populated at agent creation from the knowledge graph via buildMemberContext(), and can be refreshed via the member_status tool.
Sleep-Time Compute (Premium)
Premium agents have enable_sleeptime: true, allowing Letta to process and organize memories between conversations for improved recall quality.
Tool Access by Tier
All 16 tools are available to all tiers. Tier differentiation is based on model quality, not tool access.
| Tool | Free | Standard | Premium | Network |
|---|---|---|---|---|
conversation_search | Yes | Yes | Yes | Yes |
memory_replace | Yes | Yes | Yes | Yes |
memory_insert | Yes | Yes | Yes | Yes |
neo4j_query | Yes | Yes | Yes | Yes |
member_status | Yes | Yes | Yes | Yes |
solana_portfolio | Yes | Yes | Yes | Yes |
graphiti_search_facts | Yes | Yes | Yes | Yes |
graphiti_search_nodes | Yes | Yes | Yes | Yes |
archival_memory_search | Yes | Yes | Yes | Yes |
archival_memory_insert | Yes | Yes | Yes | Yes |
graphiti_add_episode | Yes | Yes | Yes | Yes |
graphiti_get_episodes | Yes | Yes | Yes | Yes |
web_search | Yes | Yes | Yes | Yes |
solana_transactions | Yes | Yes | Yes | Yes |
governance_status | Yes | Yes | Yes | Yes |
circle_activity | Yes | Yes | Yes | Yes |
Knowledge Flow
Information moves through the system in a cycle:
1. Documentation (markdown, MDX, research docs)
|
v [POST /api/fixie/archives/ingest]
2. Letta Archives (chunked passages, searchable)
|
v [archival_memory_search]
3. Agent Conversations (agent reads archives, answers member questions)
|
v [add_episode]
4. Graphiti (entity extraction, temporal edges, deduplication)
|
v [search_facts, search_nodes]
5. Future Conversations (agent recalls learned facts, refines answers)Key properties of this flow:
- Archives are static: updated when docs change, not during conversations
- Graphiti is dynamic: grows as agents have conversations and learn facts
- Agent memory is ephemeral: context and preferences blocks are per-agent, refreshed from the graph
- Isolation is enforced:
group_idon Graphiti nodes, archive attachment on agents, conversation isolation on network agents
References
- Letta (formerly MemGPT) Framework -- AI agent memory architecture
- Graphiti (Zep) -- Temporal knowledge graph
- Packer, C. et al. "MemGPT: Towards LLMs as Operating Systems." arXiv:2310.08560, 2023 -- Foundational paper for Letta's memory model