Skip to content
LOPS Docs

Graphiti Memory Operator

The Graphiti Memory operator provides a stateful, graph-based memory layer for AI agents. It ingests new messages into a knowledge graph and retrieves relevant historical context, enabling agents to maintain long-term memory and contextual awareness across conversations.

Graphiti Memory enables:

  • Persistent Agent Memory: Store important information across conversation sessions
  • Context Retrieval: Find relevant historical context based on current queries
  • Session Management: Organize memory by session ID for conversation continuity
  • Namespace Support: Isolate memory spaces by project or user
  • Tool Integration: Seamless integration with Agent operators for automated memory management

Agent Tool Integration

Section titled “Agent Tool Integration”
🔧 GetTool Enabled 1 tool

This operator exposes 1 tool that allow Agent and Gemini Live LOPs to provide automated memory management for AI agents including storing conversations and retrieving relevant context.

Use the Tool Debugger operator to inspect exact tool definitions, schemas, and parameters.

The Graphiti Memory operator automatically exposes an agent_memory tool when connected to an Agent, enabling automatic memory storage and retrieval during conversations.

Key Features

Section titled “Key Features”

Memory Operations

Section titled “Memory Operations”
  • Store: Ingest new messages and facts into the knowledge graph
  • Retrieve: Find relevant context from historical conversations
  • Session Tracking: Maintain conversation continuity with session IDs
  • Temporal Awareness: Track when information was stored and accessed

Integration Capabilities

Section titled “Integration Capabilities”
  • Agent Tool: Exposed as a tool for automated agent memory management
  • Graphiti Index Connection: Connects to existing Graphiti Index operators
  • Namespace Filtering: Respects project/user boundaries for memory isolation
  • Asynchronous Processing: Non-blocking memory operations

Parameters

Section titled “Parameters”

Memory Configuration

Section titled “Memory Configuration”
Indexsource (Indexsource) op('graphiti_memory').par.Indexsource OP
Default:
None
Connect (Connect) op('graphiti_memory').par.Connect Pulse
Default:
None
Connectionstatus (Connectionstatus) op('graphiti_memory').par.Connectionstatus Toggle
Default:
None
Sessionid (Sessionid) op('graphiti_memory').par.Sessionid String
Default:
None
Inputmessage (Inputmessage) op('graphiti_memory').par.Inputmessage String
Default:
None
Process (Process) op('graphiti_memory').par.Process Pulse
Default:
None
Autoprocess (Autoprocess) op('graphiti_memory').par.Autoprocess Toggle
Default:
true
Topk (Topk) op('graphiti_memory').par.Topk Integer
Default:
3
Status (Status) op('graphiti_memory').par.Status String
Default:
None

Namespace Management

Section titled “Namespace Management”
Userid (Userid) op('graphiti_memory').par.Userid String
Default:
None
Usenamespace (Usenamespace) op('graphiti_memory').par.Usenamespace Toggle
Default:
true

Usage

Section titled “Usage”

Basic Setup

Section titled “Basic Setup”
  1. Connect to Graphiti Index: Set Index Source parameter to reference your Graphiti Index operator
  2. Configure Session: Set Session ID for conversation tracking
  3. Connect: Use Connect pulse to establish the connection

Memory Operations

Section titled “Memory Operations”

Storing Information:

  1. Enter information in ‘Input Message’ field
  2. Set unique Session ID (e.g., ‘conversation_123’)
  3. Click ‘Process’ to store in knowledge graph

Retrieving Context:

  1. Enter search query in ‘Input Message’ field
  2. Adjust ‘Top K’ parameter for result limit (default: 5)
  3. Click ‘Process’ to search for relevant context
  4. Results appear in ‘context_table’ output DAT
🔧 GetTool Enabled 1 tool

This operator exposes 1 tool that allow Agent and Gemini Live LOPs to interact with this operator.

Use the Tool Debugger operator to inspect exact tool definitions, schemas, and parameters.

The operator automatically exposes an agent_memory tool when connected to an Agent, enabling automatic memory storage and retrieval during conversations.

Configuration Options

Section titled “Configuration Options”

Namespace Modes:

  • Project-Scoped: Use Namespace ON - isolates memory by project
  • User-Specific: Set User ID for individual user memory spaces
  • Global: Use Namespace OFF - shared across all contexts

Search Methods: Hybrid search combining semantic, keyword, and graph traversal

Integration

Section titled “Integration”

With Agent Operator

Section titled “With Agent Operator”
  1. Wire to Agent’s tool input - automatically detects agent_memory tool
  2. Add memory instructions to Agent’s system prompt
  3. Agent will automatically store/retrieve context during conversations

With Chat Session

Section titled “With Chat Session”
  • Wire Chat Session’s Session ID to Memory’s Session ID input
  • Each chat session gets its own memory context

Output

Section titled “Output”

Context Table columns:

  • session_id: Session identifier
  • type: ‘edge’ (relationship) or ‘node’ (entity)
  • rank: Relevance ranking (1 = most relevant)
  • details: JSON object with full context

Troubleshooting

Section titled “Troubleshooting”

Connection Problems: Verify Graphiti Index is configured and connected

Memory Not Persisting: Check namespace configuration and session ID consistency

Context Retrieval Issues: Increase Top K value, verify embeddings enabled in Graphiti Index

Section titled “Related Operators”

Research & Licensing

Zep (getzep)

Zep (getzep) is a technology company focused on building memory and knowledge management systems for AI agents. They specialize in creating practical, scalable solutions for agent memory persistence and contextual understanding in conversational AI applications.

Graphiti: Temporal Knowledge Graph Architecture

Graphiti is a temporal knowledge graph framework designed for AI agent memory systems. It automatically extracts entities and relationships from conversations and documents, creating a dynamic knowledge graph that evolves over time. The framework enables sophisticated retrieval and reasoning capabilities for enhanced agent performance.

Technical Details

  • Neo4j Backend: Leverages graph database for efficient relationship storage and querying
  • Temporal Modeling: Captures time-based relationships and entity evolution
  • Embedding Integration: Combines graph structure with vector embeddings for hybrid search

Research Impact

  • Agent Memory Systems: Advancing persistent memory capabilities for AI agents
  • Knowledge Graph Applications: Practical framework for temporal knowledge representation
  • Open Source Innovation: Democratizing access to advanced knowledge graph technologies

Citation

@misc{cui2025zep,
  title={Zep: A Temporal Knowledge Graph Architecture for Agent Memory},
  author={Cui, Cheng and Sun, Ting and Lin, Manhui and Gao, Tingquan and Zhang, Yubo and Liu, Jiaxuan and Wang, Xueqing and Zhang, Zelun and Zhou, Changda and Liu, Hongen and Zhang, Yue and Lv, Wenyu and Huang, Kui and Zhang, Yichao and Zhang, Jing and Zhang, Jun and Liu, Yi and Yu, Dianhai and Ma, Yanjun},
  journal={arXiv preprint arXiv:2501.13956},
  year={2025},
  url={https://arxiv.org/abs/2501.13956}
}

Key Research Contributions

  • Temporal knowledge graph architecture for dynamic agent memory
  • Automated entity and relationship extraction from unstructured text
  • Graph-based retrieval system for enhanced contextual understanding

License

Apache 2.0 License - This model is freely available for research and commercial use.