ƒxyzƒxyz Docs
The NetworkKnowledge Graph

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

LayerTechnologyContentScopeUpdate Frequency
Network KnowledgeLetta ArchivesBrand, tokenomics, compliance, architecture docsShared across all agentsManual ingestion when docs change
Temporal KnowledgeGraphiti (MCP)Facts extracted from conversations, entity relationshipsIsolated by group_idAutomatic during conversations
Agent MemoryLetta Core MemoryPersona, human context, preferencesPer-agent instanceUpdated 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

ArchiveContentAttached To
fxyz-networkBrand codex, tokenomics v4.1, founding philosophy, architecture overviewAll agents
fxyz-complianceMiCA VASP requirements, regulatory frameworks, jurisdictionsAll agents
fxyz-marketFX theory, mathematical models, market analysis patternsmarket_analysis persona agents
fxyz-graphNeo4j schema, Cypher patterns, ontology docs, knowledge graph structurequery_builder persona agents

How Archives Work

  • Archives are created via POST /api/fixie/archives (admin, idempotent)
  • Documents are ingested via POST /api/fixie/archives/ingest with 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_insert for 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

CapabilityDescription
Entity ExtractionLLM-driven extraction of entities and relationships from conversation text
Temporal EdgesFacts have tValid / tInvalid timestamps -- knowledge can expire or be superseded
DeduplicationSame entity mentioned differently across conversations gets merged (0.85 cosine threshold)
Group Isolationgroup_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 instance

MCP registration is done via POST /api/fixie/mcp (admin, idempotent). Graphiti is registered as a streamable_http transport.

Group-Based Isolation

Group ID PatternScopeUsed By
shared:networkNetwork-wide facts from Florin/Cypher/Sentinel conversationsNetwork agents
fixie:member:{memberId}Personal facts from member agent conversationsMember agents
fixie:project:{projectId}Project-scoped knowledge (future)Project agents

Graphiti Tools

ToolDescription
search_factsSearch temporal facts in the knowledge graph
search_nodesSearch entity nodes in the knowledge graph
add_episodeAdd a conversation episode for entity extraction
get_episodesGet 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 LabelPurpose
:EntityExtracted semantic entities (people, concepts, preferences)
:EpisodicNodeRaw episode/message storage
:CommunityNodeEntity 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

BlockFreeStandardPremiumDescription
personaYesYesYesAgent identity, domain, tool guidance, behavioral rules
humanYesYesYesMember context (DID, owner ID, memory group)
context--YesYesMember's graph neighborhood (contribution level, circles, roles, wallet)
preferences----YesLearned 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.

ToolFreeStandardPremiumNetwork
conversation_searchYesYesYesYes
memory_replaceYesYesYesYes
memory_insertYesYesYesYes
neo4j_queryYesYesYesYes
member_statusYesYesYesYes
solana_portfolioYesYesYesYes
graphiti_search_factsYesYesYesYes
graphiti_search_nodesYesYesYesYes
archival_memory_searchYesYesYesYes
archival_memory_insertYesYesYesYes
graphiti_add_episodeYesYesYesYes
graphiti_get_episodesYesYesYesYes
web_searchYesYesYesYes
solana_transactionsYesYesYesYes
governance_statusYesYesYesYes
circle_activityYesYesYesYes

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_id on Graphiti nodes, archive attachment on agents, conversation isolation on network agents

References


On this page