zep.mnm

# zep_memory.mnm
# Temporal Knowledge Graph Memory System

config {
  storage: sqlite("./data/zep.db")
  vector: auto
  graph: auto
  embedding: openai("text-embedding-3-small")
  extractor: openai("gpt-4o-mini")
}

namespace zep_agent {

  # === EPISODIC MEMORY ===
  # Stores distinct events/interactions
  memory Episode {
    session_id: string
    messages: string[]
    summary: string?
    created_at: timestamp
    
    @index session_id
  }

  # === SEMANTIC MEMORY ===
  # Stores facts with temporal validity
  memory Fact {
    content: string
    subject: string
    predicate: string
    object: string
    confidence: float[0,1]
    valid_from: timestamp
    valid_until: timestamp?
    superseded_by: string?
    
    @index subject
    @index predicate
    @invariant valid_from <= valid_until or valid_until == null
  }

  # === ENTITY MEMORY ===
  # Stores entity summaries derived from facts
  memory Entity {
    name: string
    entity_type: string
    summary: string
    fact_count: int
    last_updated: timestamp
    
    @index name
    @index entity_type
  }

  # === HANDLERS ===
  
  # When conversation ends, extrimage.pngact episodes and facts
  on conversation_end(session_id: string, messages: Message[]) {
    # Store as episode
    let episode = Episode {
      session_id: session_id,
      messages: messages |> map(m => m.content),
      summary: messages |> summarize(),
      created_at: now()
    }
    store(episode)
    
    # Extract facts and build graph
    messages
      |> extract()
      |> store()  # Auto-routes: facts -> sqlite, embeddings -> qdrant, triplets -> neo4j
  }

  # === QUERIES ===
  
  # Hybrid retrieval: semantic + graph with aliased scoring
  query GetContext(input: string): Fact[] {
    from Fact
    where semantic_match(input, threshold: 0.6) as sm
      and graph_match(input, hops: 2) as gm
      and valid_until == null
    order by (sm * 0.7 + gm * 0.3) desc
    limit 10
  }

  # Entity timeline: all facts about an entity, chronological
  query EntityHistory(entity_name: string): Fact[] {
    from Fact
    where subject == entity_name or object == entity_name
    order by valid_from asc
  }

  # Cypher: entities connected within 2 hops in the knowledge graph
  query RelatedEntities(entity: string): Entity[] {
    from Entity
    where cypher("
      MATCH (e:Entity {name: $entity})-[r*1..2]-(related:Entity)
      RETURN DISTINCT related.name as name
    ")
    limit 10
  }

  # === UPDATE RULES ===
  
  update Fact {
    on_conflict(old, new) {
      # Temporal superseding: mark old as invalid, link to new
      if new.valid_from > old.valid_from {
        old.valid_until = new.valid_from
        old.superseded_by = new.id
        store(new)
      } else {
        discard(new)
      }
    }

    # No decay - facts persist but get superseded
  }

  update Entity {
    every 6h {
      # Regenerate summaries from current facts
      let facts = EntityHistory(name)
      summary = facts |> summarize()
      fact_count = facts |> len()
      last_updated = now()
    }
  }
}