Skip to content
LOPS Docs

Graphiti Index Operator

The Graphiti Index operator creates and manages knowledge graphs using the Graphiti framework with Neo4j as the backend. Unlike traditional vector databases, Graphiti builds structured knowledge graphs that capture entities, relationships, and temporal context from your documents, enabling more sophisticated retrieval and reasoning capabilities.

What is Graphiti?

Section titled “What is Graphiti?”

Graphiti is an open-source knowledge graph framework that automatically extracts entities and relationships from unstructured text. It creates temporal, contextual knowledge graphs that understand how information evolves over time, making it ideal for applications requiring long-term memory and complex reasoning.

Graphiti Index provides:

Section titled “Graphiti Index provides:”
  • Knowledge Graph Construction: Automatically extracts entities and relationships from documents
  • Temporal Awareness: Tracks when information was created and how it evolves over time
  • Namespace Management: Supports project-specific or user-specific knowledge spaces
  • Multi-Modal Support: Handles text content with intelligent chunking strategies
  • Embedding Integration: Supports multiple embedding providers (OpenAI, Gemini, Voyage AI)

Key Features

Section titled “Key Features”

Intelligent Content Processing

Section titled “Intelligent Content Processing”
  • Smart Chunking: Multiple strategies (headers, paragraphs, sentences, characters) with overlap support
  • Content Sanitization: Prevents API errors with configurable sanitization levels
  • Batch Processing: Efficiently processes large document collections

Namespace Management

Section titled “Namespace Management”
  • Auto Project Namespace: Automatically creates project-specific knowledge spaces
  • Manual Namespace Selection: Switch between different knowledge namespaces
  • User-Specific Spaces: Optional user ID segregation for multi-user environments

Database Integration

Section titled “Database Integration”
  • Neo4j Backend: Robust graph database with ACID properties
  • Connection Management: Automatic connection handling with status monitoring
  • Index Optimization: Built-in index creation for optimal query performance

Parameters

Section titled “Parameters”

Graphiti Configuration

Section titled “Graphiti Configuration”
Status (Status) op('graphiti_index').par.Status String
Default:
None
Connectionstatus (Connectionstatus) op('graphiti_index').par.Connectionstatus Toggle
Default:
None
Connect (Connect) op('graphiti_index').par.Connect Pulse
Default:
None
Currentnamespace (Currentnamespace) op('graphiti_index').par.Currentnamespace String
Default:
None
Ingestepisodes (Ingestepisodes) op('graphiti_index').par.Ingestepisodes Pulse
Default:
None
Inputepisodes (Inputepisodes) op('graphiti_index').par.Inputepisodes OP
Default:
None
Progress (Progress) op('graphiti_index').par.Progress Float
Default:
None
Embeddingmode (Embeddingmode) op('graphiti_index').par.Embeddingmode Menu
Default:
None
Buildindices (Buildindices) op('graphiti_index').par.Buildindices Pulse
Default:
None

Model Configuration

Section titled “Model Configuration”

Understanding Model Selection

Operators utilizing LLMs (LOPs) offer flexible ways to configure the AI model used:

  • ChatTD Model (Default): By default, LOPs inherit model settings (API Server and Model) from the central ChatTD component. You can configure ChatTD via the "Controls" section in the Operator Create Dialog or its parameter page.
  • Custom Model: Select this option in "Use Model From" to override the ChatTD settings and specify the API Server and AI Model directly within this operator.
  • Controller Model: Choose this to have the LOP inherit its API Server and AI Model parameters from another operator (like a different Agent or any LOP with model parameters) specified in the Controller [ Model ] parameter. This allows centralizing model control.

The Search toggle filters the AI Model dropdown based on keywords entered in Model Search. The Show Model Info toggle (if available) displays detailed information about the selected model directly in the operator's viewer, including cost and token limits.

Available LLM Models + Providers Resources

The following links point to API key pages or documentation for the supported providers. For a complete and up-to-date list, see the LiteLLM provider docs.

Output Settings Header
Max Tokens (Maxtokens) op('graphiti_index').par.Maxtokens Int

The maximum number of tokens the model should generate.

Default:
4096
Temperature (Temperature) op('graphiti_index').par.Temperature Float

Controls randomness in the response. Lower values are more deterministic.

Default:
0.7
Model Selection Header
Use Model From (Modelselection) op('graphiti_index').par.Modelselection Menu

Choose where the model configuration comes from.

Default:
custom_model
Options:
chattd_model, custom_model, controller_model
Controller [ Model ] (Modelcontroller) op('graphiti_index').par.Modelcontroller OP

Operator providing model settings when 'Use Model From' is set to controller_model.

Default:
None
Select API Server (Apiserver) op('graphiti_index').par.Apiserver StrMenu

Select the LiteLLM provider (API server).

Default:
openrouter
Menu Options:
  • openrouter (openrouter)
  • openai (openai)
  • groq (groq)
  • gemini (gemini)
  • ollama (ollama)
  • lmstudio (lmstudio)
  • custom (custom)
AI Model (Model) op('graphiti_index').par.Model StrMenu

Specific model to request. Available options depend on the selected provider.

Default:
llama3-8b-8192
Menu Options:
  • llama3-8b-8192 (llama3-8b-8192)
Search (Search) op('graphiti_index').par.Search Toggle

Enable dynamic model search based on a pattern.

Default:
off
Options:
off, on
Model Search (Modelsearch) op('graphiti_index').par.Modelsearch Str

Pattern to filter models when Search is enabled.

Default:
"" (Empty String)
Embeddingmodel (Embeddingmodel) op('graphiti_index').par.Embeddingmodel Menu
Default:
None

Database Management

Section titled “Database Management”
Autoprojectdb (Autoprojectdb) op('graphiti_index').par.Autoprojectdb Toggle
Default:
true
Availablenamespaces (Availablenamespaces) op('graphiti_index').par.Availablenamespaces Menu
Default:
None
Refreshnamespaces (Refreshnamespaces) op('graphiti_index').par.Refreshnamespaces Pulse
Default:
None
Switchtoselected (Switchtoselected) op('graphiti_index').par.Switchtoselected Pulse
Default:
None
Newnamespace (Newnamespace) op('graphiti_index').par.Newnamespace String
Default:
None
Createnewnamespace (Createnewnamespace) op('graphiti_index').par.Createnewnamespace Pulse
Default:
None
Cleardatabase (Cleardatabase) op('graphiti_index').par.Cleardatabase Pulse
Default:
None

Content Chunking

Section titled “Content Chunking”
Enablechunking (Enablechunking) op('graphiti_index').par.Enablechunking Toggle
Default:
true
Maxchunksize (Maxchunksize) op('graphiti_index').par.Maxchunksize Integer
Default:
8000
Overlapsize (Overlapsize) op('graphiti_index').par.Overlapsize Integer
Default:
200
Chunkstrategy (Chunkstrategy) op('graphiti_index').par.Chunkstrategy Menu
Default:
None
Minchunksize (Minchunksize) op('graphiti_index').par.Minchunksize Integer
Default:
50
Aggressivesanitization (Aggressivesanitization) op('graphiti_index').par.Aggressivesanitization Toggle
Default:
false
Graphitisafesanitization (Graphitisafesanitization) op('graphiti_index').par.Graphitisafesanitization Toggle
Default:
true

Neo4j Connection

Section titled “Neo4j Connection”
Neo4juri (Neo4juri) op('graphiti_index').par.Neo4juri String
Default:
neo4j://localhost:7687
Neo4juser (Neo4juser) op('graphiti_index').par.Neo4juser String
Default:
neo4j
Neo4jpassword (Neo4jpassword) op('graphiti_index').par.Neo4jpassword String
Default:
pleasechangethispassword

Database Statistics

Section titled “Database Statistics”
Getstats (Getstats) op('graphiti_index').par.Getstats Pulse
Default:
None
Episodicnodes (Episodicnodes) op('graphiti_index').par.Episodicnodes Integer
Default:
None
Entitynodes (Entitynodes) op('graphiti_index').par.Entitynodes Integer
Default:
None
Communitynodes (Communitynodes) op('graphiti_index').par.Communitynodes Integer
Default:
None
Totalrelationships (Totalrelationships) op('graphiti_index').par.Totalrelationships Integer
Default:
None

Usage

Section titled “Usage”

Basic Workflow

Section titled “Basic Workflow”
  1. Setup Neo4j: Configure Neo4j URI, username, and password
  2. Connect: Click Connect to establish database connection
  3. Prepare Data: Create Table DAT with content, filename columns (optional: source_path, timestamp)
  4. Configure: Set chunking strategy and namespace (Auto Project recommended)
  5. Ingest: Wire Table DAT to Input Episodes and click Ingest Episodes

Document Processing

Section titled “Document Processing”

The operator intelligently processes your documents by:

  • Chunking: Breaks documents into manageable pieces using various strategies
  • Entity Extraction: Identifies people, places, concepts, and relationships
  • Graph Construction: Creates connected knowledge structures in Neo4j
  • Embedding Generation: Creates vector representations for semantic search

Configuration Options

Section titled “Configuration Options”

Chunking Strategies: Auto (recommended), Headers, Paragraphs, Sentences, Characters

Embedding Models: OpenAI text-embedding-3-small (recommended), text-embedding-3-large, Gemini, Voyage AI

Namespace Modes:

  • Auto Project: Creates unique namespace per TouchDesigner project (recommended)
  • Manual: Select or create custom namespaces for shared databases

Content Sanitization: Standard, Aggressive, or Graphiti-Safe modes to handle problematic characters

Integration

Section titled “Integration”

Troubleshooting

Section titled “Troubleshooting”

Connection Issues: Verify Neo4j is running, check URI/credentials

API Errors: Enable Graphiti-Safe Sanitization, verify API keys in ChatTD

Performance: Run Build Indices after setup, use 6000-10000 char chunks

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.