Graphiti: Temporal Graph Building Library

The Graphiti MCP Server is an experimental implementation of the Model Context Protocol (MCP) that exposes Graphiti's knowledge graph capabilities to AI assistants. It allows agents to interact with a temporally-aware knowledge graph that continuously integrates user interactions, structured/unstructured data, and external information.

Key capabilities include:

• Episode Management: Add, retrieve, and delete episodes (text, messages, or JSON).
• Entity Management: Search and manage entity nodes and relationships.
• Search: Semantic and hybrid search for facts (edges) and node summaries.
• Group Management: Organize data using group_id filtering.
• Graph Maintenance: Clear the graph and rebuild indices.
• Database Support: Supports FalkorDB (default) and Neo4j.
• Provider Support: Multiple LLM (OpenAI, Anthropic, Gemini, Groq, Azure OpenAI) and Embedding (OpenAI, Voyage, Sentence Transformers, Gemini) providers.

Graphiti is a framework for building and querying temporal context graphs for AI agents. Unlike static knowledge graphs or traditional RAG (Retrieval-Augmented Generation) which rely on batch processing and static document chunks, Graphiti is designed for dynamic, evolving data.

Key Capabilities:

• Temporal Fact Management: Tracks how facts change over time using validity windows. When information changes, old facts are invalidated rather than deleted, allowing you to query what was true at any specific point in time.
• Incremental Updates: Integrates new data (episodes) immediately without requiring full graph recomputation.
• Hybrid Retrieval: Uses a combination of semantic embeddings, keyword (BM25) search, and graph traversal for high-precision, low-latency queries.
• Provenance: Every entity and relationship traces back to the original episodes (raw data) that produced it.
• Flexible Ontology: Supports both prescribed ontology (defining entity and edge types upfront via Pydantic models) and learned ontology (allowing structure to emerge from data).

The GLiNER2Client is an experimental hybrid client that performs local entity extraction via GLiNER2 and uses a standard LLMClient for edge/fact extraction, deduplication, and summarization.

Configuration Parameters

Swapping LLM and Embedding Providers

The GLiNER2Client accepts any Graphiti LLMClient. You can replace the default Gemini providers with other supported clients:

LLM Clients:

• graphiti_core.llm_client.openai_client.OpenAIClient
• graphiti_core.llm_client.anthropic_client.AnthropicClient
• graphiti_core.llm_client.groq_client.GroqClient

Embedders:

• graphiti_core.embedder.openai.OpenAIEmbedder
• graphiti_core.embedder.voyage.VoyageAIEmbedder

Graphiti uses a layered architecture to separate high-level orchestration from low-level database operations.

1. GraphDriver (Layer 2): An abstract base class that inherits from QueryExecutor. It composes various specialized operation interfaces (e.g., EntityNodeOperations, SearchOperations) via properties. This allows the driver to support different database backends (like Neo4j or FalkorDB) by implementing these specific operation sets.

2. Namespace Wrappers (Layer 3): Thin wrappers on the Graphiti client that orchestrate non-database concerns (like generating embeddings via an EmbedderClient) before delegating the actual database work to the driver's operations. These are accessed via graphiti.nodes and graphiti.edges.

3. Graphiti Client: The primary entry point that wires together the GraphDriver, the EmbedderClient, and the NodeNamespace/EdgeNamespace wrappers.

class GraphDriver(QueryExecutor, ABC):
    @abstractmethod
    async def close(self) -> None: ...

    @abstractmethod
    def transaction(self) -> AsyncContextManager[Transaction]: ...

    @property
    @abstractmethod
    def entity_node_ops(self) -> EntityNodeOperations: ...
    # ... other ops properties ...

Graphiti uses built-in entity types for structured knowledge extraction. These are always enabled but can be customized or extended in config.yaml by modifying their descriptions.

Built-in Entity Types:

• Preference: User preferences, choices, opinions.
• Requirement: Specific needs or functionality.
• Procedure: SOPs or sequential instructions.
• Location: Physical or virtual places.
• Event: Time-bound activities.
• Person: Individual humans.
• Organization: Companies or institutions.
• Document: Books, articles, reports, etc.
• Topic: Subject of conversation (fallback).
• Object: Physical items (fallback).

Customization Example:

graphiti:
  entity_types:
    - name: "Preference"
      description: "User preferences, choices, opinions, or selections"
    - name: "Requirement"
      description: "Specific needs, features, or functionality"

Note: To disable rich-attribute extraction and use the previous attribute-free behavior, set graphiti.entity_types to an empty list.