Graphiti: dynamic knowledge graph construction and query tool (time-aware long memory scheme)

General Introduction

Graphiti is a tool developed by getzep for building and querying dynamic, time-aware knowledge graphs. It is capable of representing complex and evolving relationships between entities and querying them through a variety of methods such as temporal, full-text, semantic, and graph algorithms.Graphiti can process both unstructured and structured data, and the resulting human-readable semantic edge representations enable full-text searching and enhanced interpretive capabilities of edges during the graph construction process. The tool is widely used in application scenarios such as information retrieval, personalized agent response and dynamic data processing.

Function List

• Dynamic Knowledge Graph Construction: Supports dynamic data and intelligent updates, automatically evaluating new entities and updating existing maps.
• Time-aware queries: It can be queried based on time and supports complex temporal relationship analysis.
• Semantic Edge Generation: Generate semantically readable edges during graph construction and support full-text search.
• Multiple data source support: Ability to handle both unstructured and structured data.
• Enhanced interpretive capacity: The edges of the generated maps have enhanced interpretive capabilities for easy understanding and analysis.
• Personalized Agent Response: Personalize agent responses based on information learned from previous conversations.
• Integration with Neo4j: Support integration with Neo4j database for convenient atlas management.

Using Help

Installation process

1. Preparing the environment::
   • Ensure that the Python environment is installed.
   • Install Neo4j Desktop and create a project, add the local DBMS and start it.
2. Installing the Graphiti Library::

   pip install graphiti_core
   

3. Initializing Graphiti::
   Import and initialize Graphiti in a Python script:

   from graphiti_core import Graphiti
   from graphiti_core.nodes import EpisodeType
   

Usage Process

1. Building a Knowledge Graph::
   • Use Graphiti to build knowledge graphs of dynamic data, enabling the graph to reflect the latest context through intelligent updates and semantic edge generation.
   • For example, adding new entities and relationships:

     graph = Graphiti()
     graph.add_node("Person", name="Kendra")
     graph.add_node("Product", name="Adidas shoes")
     graph.add_edge("Kendra", "loves", "Adidas shoes")
     

2. Querying the Knowledge Graph::
   • Queries using temporal, full-text, semantic, and graph algorithms support complex temporal relations and semantic search.
   • For example, look up someone's favorite product:

     query = "MATCH (p:Person)-[r:loves]->(prod:Product) RETURN p.name, prod.name"
     results = graph.query(query)
     for result in results.
     print(f"{result['p.name']} loves {result['prod.name']}")
     

3. Personalized Agent Response::
   • Use Graphiti to store and recall relevant facts from conversations to personalize responses.
   • For example, storing and recalling dialog messages:

     graph.add_node("Conversation", context="User mentioned interest in Adidas shoes")
     relevant_facts = graph.query("MATCH (c:Conversation) RETURN c.context")
     for fact in relevant_facts: print(fact['c.context'])
     print(fact['c.context'])
     

Detailed Functions

• Smart Map Updates: Graphiti is able to automatically evaluate new entities and update them based on the current graph, thus keeping the graph up-to-date.
• Semantic and full-text search: Generating semantically readable edges during the graph construction process enables users to perform full-text searches and queries with enhanced interpretation capabilities.
• time perception: Supports time-based queries and is capable of handling complex temporal relationships and dynamic data.
• Multiple Data Source Support: The ability to handle both unstructured and structured data facilitates users to integrate and analyze data from multiple sources.

Sample application scenarios

1. Customer Service Robot::
   Graphiti can help build intelligent customer service bots that personalize responses to user queries by storing their historical conversation and behavioral data. For example, when a user inquires about a product, the bot can provide more accurate and personalized recommendations based on past conversations.
2. Financial analysis::
   Financial institutions can use Graphiti to build customer relationship maps to understand customers' investment preferences and financial behaviors. Time-aware queries analyze changes in clients' investment behavior over time, helping financial advisors provide more professional investment advice.
3. Healthcare Management::
   Healthcare organizations can use Graphiti to build patient health profile mappings that record a patient's historical medical history and treatment records. With dynamic updates and time-aware queries, doctors can gain a more comprehensive understanding of a patient's health and provide personalized healthcare solutions.
4. E-commerce recommendation system::
   E-commerce platforms can use Graphiti to build user interest graphs and record users' browsing and purchase history. Through semantic query and time-aware analysis, the platform can recommend products to users that are more in line with their interests and increase their purchase conversion rate.
5. academic research::
   Research institutions can use Graphiti to build a map of scholarly resources to record and analyze citation relationships and research trends among academic papers. Through semantic and time-aware queries, researchers can quickly find relevant research results and academic resources.