graphiti-core 0.3.7__py3-none-any.whl → 0.3.9__py3-none-any.whl

graphiti_core/edges.py

@@ -188,9 +188,9 @@ class EntityEdge(Edge):
         MATCH (source:Entity {uuid: $source_uuid}) 
         MATCH (target:Entity {uuid: $target_uuid}) 
         MERGE (source)-[r:RELATES_TO {uuid: $uuid}]->(target)
-        SET r = {uuid: $uuid, name: $name, group_id: $group_id, fact: $fact, fact_embedding: $fact_embedding, 
-        episodes: $episodes, created_at: $created_at, expired_at: $expired_at, 
-        valid_at: $valid_at, invalid_at: $invalid_at}
+        SET r = {uuid: $uuid, name: $name, group_id: $group_id, fact: $fact, episodes: $episodes, 
+        created_at: $created_at, expired_at: $expired_at, valid_at: $valid_at, invalid_at: $invalid_at}
+        WITH r CALL db.create.setRelationshipVectorProperty(r, "fact_embedding", $fact_embedding)
         RETURN r.uuid AS uuid""",
             source_uuid=self.source_node_uuid,
             target_uuid=self.target_node_uuid,

graphiti_core/embedder/openai.py

@@ -42,7 +42,7 @@ class OpenAIEmbedder(EmbedderClient):
         self.client = AsyncOpenAI(api_key=config.api_key, base_url=config.base_url)
 
     async def create(
-        self, input: str | List[str] | Iterable[int] | Iterable[Iterable[int]]
+            self, input: str | List[str] | Iterable[int] | Iterable[Iterable[int]]
     ) -> list[float]:
         result = await self.client.embeddings.create(input=input, model=self.config.embedding_model)
         return result.data[0].embedding[: self.config.embedding_dim]

graphiti_core/embedder/voyage.py

@@ -41,7 +41,7 @@ class VoyageAIEmbedder(EmbedderClient):
         self.client = voyageai.AsyncClient(api_key=config.api_key)
 
     async def create(
-        self, input: str | List[str] | Iterable[int] | Iterable[Iterable[int]]
+            self, input: str | List[str] | Iterable[int] | Iterable[Iterable[int]]
     ) -> list[float]:
         result = await self.client.embed(input, model=self.config.embedding_model)
         return result.embeddings[0][: self.config.embedding_dim]

graphiti_core/graphiti.py

@@ -21,11 +21,12 @@ from time import time
 
 from dotenv import load_dotenv
 from neo4j import AsyncGraphDatabase
+from pydantic import BaseModel
 
 from graphiti_core.edges import EntityEdge, EpisodicEdge
 from graphiti_core.embedder import EmbedderClient, OpenAIEmbedder
 from graphiti_core.llm_client import LLMClient, OpenAIClient
-from graphiti_core.nodes import EntityNode, EpisodeType, EpisodicNode
+from graphiti_core.nodes import CommunityNode, EntityNode, EpisodeType, EpisodicNode
 from graphiti_core.search.search import SearchConfig, search
 from graphiti_core.search.search_config import DEFAULT_SEARCH_LIMIT, SearchResults
 from graphiti_core.search.search_config_recipes import (
@@ -77,6 +78,12 @@ logger = logging.getLogger(__name__)
 load_dotenv()
 
 
+class AddEpisodeResults(BaseModel):
+    episode: EpisodicNode
+    nodes: list[EntityNode]
+    edges: list[EntityEdge]
+
+
 class Graphiti:
     def __init__(
         self,
@@ -245,7 +252,7 @@ class Graphiti:
         group_id: str = '',
         uuid: str | None = None,
         update_communities: bool = False,
-    ):
+    ) -> AddEpisodeResults:
         """
         Process an episode and update the graph.
 
@@ -451,6 +458,8 @@ class Graphiti:
             end = time()
             logger.info(f'Completed add_episode in {(end - start) * 1000} ms')
 
+            return AddEpisodeResults(episode=episode, nodes=nodes, edges=entity_edges)
+
         except Exception as e:
             raise e
 
@@ -567,11 +576,20 @@ class Graphiti:
         except Exception as e:
             raise e
 
-    async def build_communities(self):
+    async def build_communities(self, group_ids: list[str] | None = None) -> list[CommunityNode]:
+        """
+        Use a community clustering algorithm to find communities of nodes. Create community nodes summarising
+        the content of these communities.
+        ----------
+        query : list[str] | None
+            Optional. Create communities only for the listed group_ids. If blank the entire graph will be used.
+        """
         # Clear existing communities
         await remove_communities(self.driver)
 
-        community_nodes, community_edges = await build_communities(self.driver, self.llm_client)
+        community_nodes, community_edges = await build_communities(
+            self.driver, self.llm_client, group_ids
+        )
 
         await asyncio.gather(
             *[node.generate_name_embedding(self.embedder) for node in community_nodes]
@@ -580,6 +598,8 @@ class Graphiti:
         await asyncio.gather(*[node.save(self.driver) for node in community_nodes])
         await asyncio.gather(*[edge.save(self.driver) for edge in community_edges])
 
+        return community_nodes
+
     async def search(
         self,
         query: str,
@@ -700,18 +720,17 @@ class Graphiti:
         ).nodes
         return nodes
 
+    async def get_episode_mentions(self, episode_uuids: list[str]) -> SearchResults:
+        episodes = await EpisodicNode.get_by_uuids(self.driver, episode_uuids)
 
-async def get_episode_mentions(self, episode_uuids: list[str]) -> SearchResults:
-    episodes = await EpisodicNode.get_by_uuids(self.driver, episode_uuids)
-
-    edges_list = await asyncio.gather(
-        *[EntityEdge.get_by_uuids(self.driver, episode.entity_edges) for episode in episodes]
-    )
+        edges_list = await asyncio.gather(
+            *[EntityEdge.get_by_uuids(self.driver, episode.entity_edges) for episode in episodes]
+        )
 
-    edges: list[EntityEdge] = [edge for lst in edges_list for edge in lst]
+        edges: list[EntityEdge] = [edge for lst in edges_list for edge in lst]
 
-    nodes = await get_mentioned_nodes(self.driver, episodes)
+        nodes = await get_mentioned_nodes(self.driver, episodes)
 
-    communities = await get_communities_by_nodes(self.driver, nodes)
+        communities = await get_communities_by_nodes(self.driver, nodes)
 
-    return SearchResults(edges=edges, nodes=nodes, communities=communities)
+        return SearchResults(edges=edges, nodes=nodes, communities=communities)

graphiti_core/helpers.py

@@ -16,6 +16,7 @@ limitations under the License.
 
 from datetime import datetime
 
+import numpy as np
 from neo4j import time as neo4j_time
 
 
@@ -25,7 +26,7 @@ def parse_db_date(neo_date: neo4j_time.DateTime | None) -> datetime | None:
 
 def lucene_sanitize(query: str) -> str:
     # Escape special characters from a query before passing into Lucene
-    # + - && || ! ( ) { } [ ] ^ " ~ * ? : \
+    # + - && || ! ( ) { } [ ] ^ " ~ * ? : \ /
     escape_map = str.maketrans(
         {
             '+': r'\+',
@@ -46,8 +47,21 @@ def lucene_sanitize(query: str) -> str:
             '?': r'\?',
             ':': r'\:',
             '\\': r'\\',
+            '/': r'\/',
         }
     )
 
     sanitized = query.translate(escape_map)
     return sanitized
+
+
+def normalize_l2(embedding: list[float]) -> list[float]:
+    embedding_array = np.array(embedding)
+    if embedding_array.ndim == 1:
+        norm = np.linalg.norm(embedding_array)
+        if norm == 0:
+            return embedding_array.tolist()
+        return (embedding_array / norm).tolist()
+    else:
+        norm = np.linalg.norm(embedding_array, 2, axis=1, keepdims=True)
+        return (np.where(norm == 0, embedding_array, embedding_array / norm)).tolist()

graphiti_core/nodes.py

@@ -225,7 +225,8 @@ class EntityNode(Node):
         result = await driver.execute_query(
             """
         MERGE (n:Entity {uuid: $uuid})
-        SET n = {uuid: $uuid, name: $name, name_embedding: $name_embedding, group_id: $group_id, summary: $summary, created_at: $created_at}
+        SET n = {uuid: $uuid, name: $name, group_id: $group_id, summary: $summary, created_at: $created_at}
+        WITH n CALL db.create.setNodeVectorProperty(n, "name_embedding", $name_embedding)
         RETURN n.uuid AS uuid""",
             uuid=self.uuid,
             name=self.name,
@@ -308,7 +309,8 @@ class CommunityNode(Node):
         result = await driver.execute_query(
             """
         MERGE (n:Community {uuid: $uuid})
-        SET n = {uuid: $uuid, name: $name, name_embedding: $name_embedding, group_id: $group_id, summary: $summary, created_at: $created_at}
+        SET n = {uuid: $uuid, name: $name, group_id: $group_id, summary: $summary, created_at: $created_at}
+        WITH n CALL db.create.setNodeVectorProperty(n, "name_embedding", $name_embedding)
         RETURN n.uuid AS uuid""",
             uuid=self.uuid,
             name=self.name,

graphiti_core/prompts/eval.py

@@ -23,11 +23,33 @@ from .models import Message, PromptFunction, PromptVersion
 class Prompt(Protocol):
     qa_prompt: PromptVersion
     eval_prompt: PromptVersion
+    query_expansion: PromptVersion
 
 
 class Versions(TypedDict):
     qa_prompt: PromptFunction
     eval_prompt: PromptFunction
+    query_expansion: PromptFunction
+
+
+def query_expansion(context: dict[str, Any]) -> list[Message]:
+    sys_prompt = """You are an expert at rephrasing questions into queries used in a database retrieval system"""
+
+    user_prompt = f"""
+    Bob is asking Alice a question, are you able to rephrase the question into a simpler one about Alice in the third person
+    that maintains the relevant context?
+    <QUESTION>
+    {json.dumps(context['query'])}
+    </QUESTION>
+    respond with a JSON object in the following format:
+    {{
+        "query": "query optimized for database search"
+    }}
+    """
+    return [
+        Message(role='system', content=sys_prompt),
+        Message(role='user', content=user_prompt),
+    ]
 
 
 def qa_prompt(context: dict[str, Any]) -> list[Message]:
@@ -38,7 +60,7 @@ def qa_prompt(context: dict[str, Any]) -> list[Message]:
     You are given the following entity summaries and facts to help you determine the answer to your question.
     <ENTITY_SUMMARIES>
     {json.dumps(context['entity_summaries'])}
-    </ENTITY_SUMMARIES
+    </ENTITY_SUMMARIES>
     <FACTS>
     {json.dumps(context['facts'])}
     </FACTS>
@@ -87,4 +109,8 @@ def eval_prompt(context: dict[str, Any]) -> list[Message]:
     ]
 
 
-versions: Versions = {'qa_prompt': qa_prompt, 'eval_prompt': eval_prompt}
+versions: Versions = {
+    'qa_prompt': qa_prompt,
+    'eval_prompt': eval_prompt,
+    'query_expansion': query_expansion,
+}

graphiti_core/prompts/extract_edge_dates.py

@@ -37,7 +37,6 @@ def v1(context: dict[str, Any]) -> list[Message]:
             role='user',
             content=f"""
             Edge:
-            Edge Name: {context['edge_name']}
             Fact: {context['edge_fact']}
 
             Current Episode: {context['current_episode']}
@@ -56,17 +55,17 @@ def v1(context: dict[str, Any]) -> list[Message]:
             Guidelines:
             1. Use ISO 8601 format (YYYY-MM-DDTHH:MM:SSZ) for datetimes.
             2. Use the reference timestamp as the current time when determining the valid_at and invalid_at dates.
-            3. If no temporal information is found that establishes or changes the relationship, leave the fields as null.
-            4. Do not infer dates from related events. Only use dates that are directly stated to establish or change the relationship.
-			5. For relative time mentions directly related to the relationship, calculate the actual datetime based on the reference timestamp.
-            6. If only a date is mentioned without a specific time, use 00:00:00 (midnight) for that date.
-            7. If only a year is mentioned, use January 1st of that year at 00:00:00.
+            3. If the fact is written in the present tense, use the Reference Timestamp for the valid_at date
+            4. If no temporal information is found that establishes or changes the relationship, leave the fields as null.
+            5. Do not infer dates from related events. Only use dates that are directly stated to establish or change the relationship.
+			6. For relative time mentions directly related to the relationship, calculate the actual datetime based on the reference timestamp.
+            7. If only a date is mentioned without a specific time, use 00:00:00 (midnight) for that date.
+            8. If only a year is mentioned, use January 1st of that year at 00:00:00.
             9. Always include the time zone offset (use Z for UTC if no specific time zone is mentioned).
             Respond with a JSON object:
             {{
-                "valid_at": "YYYY-MM-DDTHH:MM:SSZ or null",
-                "invalid_at": "YYYY-MM-DDTHH:MM:SSZ or null",
-                "explanation": "Brief explanation of why these dates were chosen or why they were set to null"
+                "valid_at": "YYYY-MM-DDTHH:MM:SS.SSSSSSZ or null",
+                "invalid_at": "YYYY-MM-DDTHH:MM:SS.SSSSSSZ or null",
             }}
             """,
         ),

graphiti_core/prompts/extract_edges.py

@@ -113,8 +113,9 @@ def v2(context: dict[str, Any]) -> list[Message]:
         2. Each edge should represent a clear relationship between two DISTINCT nodes.
         3. The relation_type should be a concise, all-caps description of the relationship (e.g., LOVES, IS_FRIENDS_WITH, WORKS_FOR).
         4. Provide a more detailed fact describing the relationship.
-        5. Consider temporal aspects of relationships when relevant.
-        6. Avoid using the same node as the source and target of a relationship
+        5. The fact should include any specific relevant information, including numeric information
+        6. Consider temporal aspects of relationships when relevant.
+        7. Avoid using the same node as the source and target of a relationship
 
         Respond with a JSON object in the following format:
         {{

graphiti_core/prompts/invalidate_edges.py

@@ -82,7 +82,7 @@ def v2(context: dict[str, Any]) -> list[Message]:
         Message(
             role='user',
             content=f"""
-               Based on the provided Existing Edges and a New Edge, determine which existing edges, if any, should be marked as invalidated due to contradictions with the New Edge.
+               Based on the provided Existing Edges and a New Edge, determine which existing edges, if any, should be marked as invalidated due to invalidations with the New Edge.
 
                 Existing Edges:
                 {context['existing_edges']}

graphiti_core/search/search.py

@@ -29,13 +29,10 @@ from graphiti_core.search.search_config import (
     DEFAULT_SEARCH_LIMIT,
     CommunityReranker,
     CommunitySearchConfig,
-    CommunitySearchMethod,
     EdgeReranker,
     EdgeSearchConfig,
-    EdgeSearchMethod,
     NodeReranker,
     NodeSearchConfig,
-    NodeSearchMethod,
     SearchConfig,
     SearchResults,
 )
@@ -45,6 +42,7 @@ from graphiti_core.search.search_utils import (
     edge_fulltext_search,
     edge_similarity_search,
     episode_mentions_reranker,
+    maximal_marginal_relevance,
     node_distance_reranker,
     node_fulltext_search,
     node_similarity_search,
@@ -120,22 +118,18 @@ async def edge_search(
     if config is None:
         return []
 
-    search_results: list[list[EntityEdge]] = []
+    query_vector = await embedder.create(input=[query])
 
-    if EdgeSearchMethod.bm25 in config.search_methods:
-        text_search = await edge_fulltext_search(driver, query, None, None, group_ids, 2 * limit)
-        search_results.append(text_search)
-
-    if EdgeSearchMethod.cosine_similarity in config.search_methods:
-        search_vector = await embedder.create(input=[query])
-
-        similarity_search = await edge_similarity_search(
-            driver, search_vector, None, None, group_ids, 2 * limit
+    search_results: list[list[EntityEdge]] = list(
+        await asyncio.gather(
+            *[
+                edge_fulltext_search(driver, query, None, None, group_ids, 2 * limit),
+                edge_similarity_search(
+                    driver, query_vector, None, None, group_ids, 2 * limit, config.sim_min_score
+                ),
+            ]
         )
-        search_results.append(similarity_search)
-
-    if len(search_results) > 1 and config.reranker is None:
-        raise SearchRerankerError('Multiple edge searches enabled without a reranker')
+    )
 
     edge_uuid_map = {edge.uuid: edge for result in search_results for edge in result}
 
@@ -144,6 +138,15 @@ async def edge_search(
         search_result_uuids = [[edge.uuid for edge in result] for result in search_results]
 
         reranked_uuids = rrf(search_result_uuids)
+    elif config.reranker == EdgeReranker.mmr:
+        search_result_uuids_and_vectors = [
+            (edge.uuid, edge.fact_embedding if edge.fact_embedding is not None else [0.0] * 1024)
+            for result in search_results
+            for edge in result
+        ]
+        reranked_uuids = maximal_marginal_relevance(
+            query_vector, search_result_uuids_and_vectors, config.mmr_lambda
+        )
     elif config.reranker == EdgeReranker.node_distance:
         if center_node_uuid is None:
             raise SearchRerankerError('No center node provided for Node Distance reranker')
@@ -184,22 +187,18 @@ async def node_search(
     if config is None:
         return []
 
-    search_results: list[list[EntityNode]] = []
-
-    if NodeSearchMethod.bm25 in config.search_methods:
-        text_search = await node_fulltext_search(driver, query, group_ids, 2 * limit)
-        search_results.append(text_search)
+    query_vector = await embedder.create(input=[query])
 
-    if NodeSearchMethod.cosine_similarity in config.search_methods:
-        search_vector = await embedder.create(input=[query])
-
-        similarity_search = await node_similarity_search(
-            driver, search_vector, group_ids, 2 * limit
+    search_results: list[list[EntityNode]] = list(
+        await asyncio.gather(
+            *[
+                node_fulltext_search(driver, query, group_ids, 2 * limit),
+                node_similarity_search(
+                    driver, query_vector, group_ids, 2 * limit, config.sim_min_score
+                ),
+            ]
         )
-        search_results.append(similarity_search)
-
-    if len(search_results) > 1 and config.reranker is None:
-        raise SearchRerankerError('Multiple node searches enabled without a reranker')
+    )
 
     search_result_uuids = [[node.uuid for node in result] for result in search_results]
     node_uuid_map = {node.uuid: node for result in search_results for node in result}
@@ -207,6 +206,15 @@ async def node_search(
     reranked_uuids: list[str] = []
     if config.reranker == NodeReranker.rrf:
         reranked_uuids = rrf(search_result_uuids)
+    elif config.reranker == NodeReranker.mmr:
+        search_result_uuids_and_vectors = [
+            (node.uuid, node.name_embedding if node.name_embedding is not None else [0.0] * 1024)
+            for result in search_results
+            for node in result
+        ]
+        reranked_uuids = maximal_marginal_relevance(
+            query_vector, search_result_uuids_and_vectors, config.mmr_lambda
+        )
     elif config.reranker == NodeReranker.episode_mentions:
         reranked_uuids = await episode_mentions_reranker(driver, search_result_uuids)
     elif config.reranker == NodeReranker.node_distance:
@@ -232,22 +240,18 @@ async def community_search(
     if config is None:
         return []
 
-    search_results: list[list[CommunityNode]] = []
-
-    if CommunitySearchMethod.bm25 in config.search_methods:
-        text_search = await community_fulltext_search(driver, query, group_ids, 2 * limit)
-        search_results.append(text_search)
-
-    if CommunitySearchMethod.cosine_similarity in config.search_methods:
-        search_vector = await embedder.create(input=[query])
+    query_vector = await embedder.create(input=[query])
 
-        similarity_search = await community_similarity_search(
-            driver, search_vector, group_ids, 2 * limit
+    search_results: list[list[CommunityNode]] = list(
+        await asyncio.gather(
+            *[
+                community_fulltext_search(driver, query, group_ids, 2 * limit),
+                community_similarity_search(
+                    driver, query_vector, group_ids, 2 * limit, config.sim_min_score
+                ),
+            ]
         )
-        search_results.append(similarity_search)
-
-    if len(search_results) > 1 and config.reranker is None:
-        raise SearchRerankerError('Multiple node searches enabled without a reranker')
+    )
 
     search_result_uuids = [[community.uuid for community in result] for result in search_results]
     community_uuid_map = {
@@ -257,6 +261,18 @@ async def community_search(
     reranked_uuids: list[str] = []
     if config.reranker == CommunityReranker.rrf:
         reranked_uuids = rrf(search_result_uuids)
+    elif config.reranker == CommunityReranker.mmr:
+        search_result_uuids_and_vectors = [
+            (
+                community.uuid,
+                community.name_embedding if community.name_embedding is not None else [0.0] * 1024,
+            )
+            for result in search_results
+            for community in result
+        ]
+        reranked_uuids = maximal_marginal_relevance(
+            query_vector, search_result_uuids_and_vectors, config.mmr_lambda
+        )
 
     reranked_communities = [community_uuid_map[uuid] for uuid in reranked_uuids]
 

graphiti_core/search/search_config.py

@@ -20,6 +20,7 @@ from pydantic import BaseModel, Field
 
 from graphiti_core.edges import EntityEdge
 from graphiti_core.nodes import CommunityNode, EntityNode
+from graphiti_core.search.search_utils import DEFAULT_MIN_SCORE, DEFAULT_MMR_LAMBDA
 
 DEFAULT_SEARCH_LIMIT = 10
 
@@ -43,31 +44,40 @@ class EdgeReranker(Enum):
     rrf = 'reciprocal_rank_fusion'
     node_distance = 'node_distance'
     episode_mentions = 'episode_mentions'
+    mmr = 'mmr'
 
 
 class NodeReranker(Enum):
     rrf = 'reciprocal_rank_fusion'
     node_distance = 'node_distance'
     episode_mentions = 'episode_mentions'
+    mmr = 'mmr'
 
 
 class CommunityReranker(Enum):
     rrf = 'reciprocal_rank_fusion'
+    mmr = 'mmr'
 
 
 class EdgeSearchConfig(BaseModel):
     search_methods: list[EdgeSearchMethod]
-    reranker: EdgeReranker | None
+    reranker: EdgeReranker = Field(default=EdgeReranker.rrf)
+    sim_min_score: float = Field(default=DEFAULT_MIN_SCORE)
+    mmr_lambda: float = Field(default=DEFAULT_MMR_LAMBDA)
 
 
 class NodeSearchConfig(BaseModel):
     search_methods: list[NodeSearchMethod]
-    reranker: NodeReranker | None
+    reranker: NodeReranker = Field(default=NodeReranker.rrf)
+    sim_min_score: float = Field(default=DEFAULT_MIN_SCORE)
+    mmr_lambda: float = Field(default=DEFAULT_MMR_LAMBDA)
 
 
 class CommunitySearchConfig(BaseModel):
     search_methods: list[CommunitySearchMethod]
-    reranker: CommunityReranker | None
+    reranker: CommunityReranker = Field(default=CommunityReranker.rrf)
+    sim_min_score: float = Field(default=DEFAULT_MIN_SCORE)
+    mmr_lambda: float = Field(default=DEFAULT_MMR_LAMBDA)
 
 
 class SearchConfig(BaseModel):

graphiti_core/search/search_config_recipes.py

@@ -43,6 +43,22 @@ COMBINED_HYBRID_SEARCH_RRF = SearchConfig(
     ),
 )
 
+# Performs a hybrid search with mmr reranking over edges, nodes, and communities
+COMBINED_HYBRID_SEARCH_MMR = SearchConfig(
+    edge_config=EdgeSearchConfig(
+        search_methods=[EdgeSearchMethod.bm25, EdgeSearchMethod.cosine_similarity],
+        reranker=EdgeReranker.mmr,
+    ),
+    node_config=NodeSearchConfig(
+        search_methods=[NodeSearchMethod.bm25, NodeSearchMethod.cosine_similarity],
+        reranker=NodeReranker.mmr,
+    ),
+    community_config=CommunitySearchConfig(
+        search_methods=[CommunitySearchMethod.bm25, CommunitySearchMethod.cosine_similarity],
+        reranker=CommunityReranker.mmr,
+    ),
+)
+
 # performs a hybrid search over edges with rrf reranking
 EDGE_HYBRID_SEARCH_RRF = SearchConfig(
     edge_config=EdgeSearchConfig(
@@ -51,6 +67,14 @@ EDGE_HYBRID_SEARCH_RRF = SearchConfig(
     )
 )
 
+# performs a hybrid search over edges with mmr reranking
+EDGE_HYBRID_SEARCH_mmr = SearchConfig(
+    edge_config=EdgeSearchConfig(
+        search_methods=[EdgeSearchMethod.bm25, EdgeSearchMethod.cosine_similarity],
+        reranker=EdgeReranker.mmr,
+    )
+)
+
 # performs a hybrid search over edges with node distance reranking
 EDGE_HYBRID_SEARCH_NODE_DISTANCE = SearchConfig(
     edge_config=EdgeSearchConfig(
@@ -75,6 +99,14 @@ NODE_HYBRID_SEARCH_RRF = SearchConfig(
     )
 )
 
+# performs a hybrid search over nodes with mmr reranking
+NODE_HYBRID_SEARCH_MMR = SearchConfig(
+    node_config=NodeSearchConfig(
+        search_methods=[NodeSearchMethod.bm25, NodeSearchMethod.cosine_similarity],
+        reranker=NodeReranker.mmr,
+    )
+)
+
 # performs a hybrid search over nodes with node distance reranking
 NODE_HYBRID_SEARCH_NODE_DISTANCE = SearchConfig(
     node_config=NodeSearchConfig(
@@ -98,3 +130,11 @@ COMMUNITY_HYBRID_SEARCH_RRF = SearchConfig(
         reranker=CommunityReranker.rrf,
     )
 )
+
+# performs a hybrid search over communities with mmr reranking
+COMMUNITY_HYBRID_SEARCH_MMR = SearchConfig(
+    community_config=CommunitySearchConfig(
+        search_methods=[CommunitySearchMethod.bm25, CommunitySearchMethod.cosine_similarity],
+        reranker=CommunityReranker.mmr,
+    )
+)

graphiti_core/search/search_utils.py

@@ -19,10 +19,11 @@ import logging
 from collections import defaultdict
 from time import time
 
+import numpy as np
 from neo4j import AsyncDriver, Query
 
 from graphiti_core.edges import EntityEdge, get_entity_edge_from_record
-from graphiti_core.helpers import lucene_sanitize
+from graphiti_core.helpers import lucene_sanitize, normalize_l2
 from graphiti_core.nodes import (
     CommunityNode,
     EntityNode,
@@ -34,6 +35,8 @@ from graphiti_core.nodes import (
 logger = logging.getLogger(__name__)
 
 RELEVANT_SCHEMA_LIMIT = 3
+DEFAULT_MIN_SCORE = 0.6
+DEFAULT_MMR_LAMBDA = 0.5
 
 
 def fulltext_query(query: str, group_ids: list[str] | None = None):
@@ -52,8 +55,23 @@ def fulltext_query(query: str, group_ids: list[str] | None = None):
     return full_query
 
 
+async def get_episodes_by_mentions(
+        driver: AsyncDriver,
+        nodes: list[EntityNode],
+        edges: list[EntityEdge],
+        limit: int = RELEVANT_SCHEMA_LIMIT,
+) -> list[EpisodicNode]:
+    episode_uuids: list[str] = []
+    for edge in edges:
+        episode_uuids.extend(edge.episodes)
+
+    episodes = await EpisodicNode.get_by_uuids(driver, episode_uuids[:limit])
+
+    return episodes
+
+
 async def get_mentioned_nodes(
-    driver: AsyncDriver, episodes: list[EpisodicNode]
+        driver: AsyncDriver, episodes: list[EpisodicNode]
 ) -> list[EntityNode]:
     episode_uuids = [episode.uuid for episode in episodes]
     records, _, _ = await driver.execute_query(
@@ -76,7 +94,7 @@ async def get_mentioned_nodes(
 
 
 async def get_communities_by_nodes(
-    driver: AsyncDriver, nodes: list[EntityNode]
+        driver: AsyncDriver, nodes: list[EntityNode]
 ) -> list[CommunityNode]:
     node_uuids = [node.uuid for node in nodes]
     records, _, _ = await driver.execute_query(
@@ -99,12 +117,12 @@ async def get_communities_by_nodes(
 
 
 async def edge_fulltext_search(
-    driver: AsyncDriver,
-    query: str,
-    source_node_uuid: str | None,
-    target_node_uuid: str | None,
-    group_ids: list[str] | None = None,
-    limit=RELEVANT_SCHEMA_LIMIT,
+        driver: AsyncDriver,
+        query: str,
+        source_node_uuid: str | None,
+        target_node_uuid: str | None,
+        group_ids: list[str] | None = None,
+        limit=RELEVANT_SCHEMA_LIMIT,
 ) -> list[EntityEdge]:
     # fulltext search over facts
     fuzzy_query = fulltext_query(query, group_ids)
@@ -113,9 +131,6 @@ async def edge_fulltext_search(
               CALL db.index.fulltext.queryRelationships("edge_name_and_fact", $query) 
               YIELD relationship AS rel, score
               MATCH (n:Entity)-[r {uuid: rel.uuid}]-(m:Entity)
-              WHERE ($source_uuid IS NULL OR n.uuid = $source_uuid)
-              AND ($target_uuid IS NULL OR m.uuid = $target_uuid)
-              AND ($group_ids IS NULL OR n.group_id IN $group_ids)
               RETURN 
                     r.uuid AS uuid,
                     r.group_id AS group_id,
@@ -147,21 +162,24 @@ async def edge_fulltext_search(
 
 
 async def edge_similarity_search(
-    driver: AsyncDriver,
-    search_vector: list[float],
-    source_node_uuid: str | None,
-    target_node_uuid: str | None,
-    group_ids: list[str] | None = None,
-    limit: int = RELEVANT_SCHEMA_LIMIT,
+        driver: AsyncDriver,
+        search_vector: list[float],
+        source_node_uuid: str | None,
+        target_node_uuid: str | None,
+        group_ids: list[str] | None = None,
+        limit: int = RELEVANT_SCHEMA_LIMIT,
+        min_score: float = DEFAULT_MIN_SCORE,
 ) -> list[EntityEdge]:
     # vector similarity search over embedded facts
     query = Query("""
+                CYPHER runtime = parallel parallelRuntimeSupport=all
                 MATCH (n:Entity)-[r:RELATES_TO]-(m:Entity)
                 WHERE ($group_ids IS NULL OR r.group_id IN $group_ids)
                 AND ($source_uuid IS NULL OR n.uuid = $source_uuid)
                 AND ($target_uuid IS NULL OR m.uuid = $target_uuid)
+                WITH n, r, m, vector.similarity.cosine(r.fact_embedding, $search_vector) AS score
+                WHERE score > $min_score
                 RETURN
-                    vector.similarity.cosine(r.fact_embedding, $search_vector) AS score,
                     r.uuid AS uuid,
                     r.group_id AS group_id,
                     n.uuid AS source_node_uuid,
@@ -185,6 +203,7 @@ async def edge_similarity_search(
         target_uuid=target_node_uuid,
         group_ids=group_ids,
         limit=limit,
+        min_score=min_score,
     )
 
     edges = [get_entity_edge_from_record(record) for record in records]
@@ -193,10 +212,10 @@ async def edge_similarity_search(
 
 
 async def node_fulltext_search(
-    driver: AsyncDriver,
-    query: str,
-    group_ids: list[str] | None = None,
-    limit=RELEVANT_SCHEMA_LIMIT,
+        driver: AsyncDriver,
+        query: str,
+        group_ids: list[str] | None = None,
+        limit=RELEVANT_SCHEMA_LIMIT,
 ) -> list[EntityNode]:
     # BM25 search to get top nodes
     fuzzy_query = fulltext_query(query, group_ids)
@@ -205,7 +224,6 @@ async def node_fulltext_search(
         """
     CALL db.index.fulltext.queryNodes("node_name_and_summary", $query) 
     YIELD node AS n, score
-    WHERE $group_ids IS NULL OR n.group_id IN $group_ids
     RETURN
         n.uuid AS uuid,
         n.group_id AS group_id, 
@@ -226,18 +244,21 @@ async def node_fulltext_search(
 
 
 async def node_similarity_search(
-    driver: AsyncDriver,
-    search_vector: list[float],
-    group_ids: list[str] | None = None,
-    limit=RELEVANT_SCHEMA_LIMIT,
+        driver: AsyncDriver,
+        search_vector: list[float],
+        group_ids: list[str] | None = None,
+        limit=RELEVANT_SCHEMA_LIMIT,
+        min_score: float = DEFAULT_MIN_SCORE,
 ) -> list[EntityNode]:
     # vector similarity search over entity names
     records, _, _ = await driver.execute_query(
         """
+                CYPHER runtime = parallel parallelRuntimeSupport=all
                 MATCH (n:Entity)
                 WHERE $group_ids IS NULL OR n.group_id IN $group_ids
+                WITH n, vector.similarity.cosine(n.name_embedding, $search_vector) AS score
+                WHERE score > $min_score
                 RETURN
-                    vector.similarity.cosine(n.name_embedding, $search_vector) AS score,
                     n.uuid As uuid,
                     n.group_id AS group_id,
                     n.name AS name, 
@@ -250,6 +271,7 @@ async def node_similarity_search(
         search_vector=search_vector,
         group_ids=group_ids,
         limit=limit,
+        min_score=min_score,
     )
     nodes = [get_entity_node_from_record(record) for record in records]
 
@@ -257,10 +279,10 @@ async def node_similarity_search(
 
 
 async def community_fulltext_search(
-    driver: AsyncDriver,
-    query: str,
-    group_ids: list[str] | None = None,
-    limit=RELEVANT_SCHEMA_LIMIT,
+        driver: AsyncDriver,
+        query: str,
+        group_ids: list[str] | None = None,
+        limit=RELEVANT_SCHEMA_LIMIT,
 ) -> list[CommunityNode]:
     # BM25 search to get top communities
     fuzzy_query = fulltext_query(query, group_ids)
@@ -269,8 +291,6 @@ async def community_fulltext_search(
         """
     CALL db.index.fulltext.queryNodes("community_name", $query) 
     YIELD node AS comm, score
-    MATCH (comm:Community)
-    WHERE $group_ids IS NULL OR comm.group_id in $group_ids
     RETURN
         comm.uuid AS uuid,
         comm.group_id AS group_id, 
@@ -291,18 +311,21 @@ async def community_fulltext_search(
 
 
 async def community_similarity_search(
-    driver: AsyncDriver,
-    search_vector: list[float],
-    group_ids: list[str] | None = None,
-    limit=RELEVANT_SCHEMA_LIMIT,
+        driver: AsyncDriver,
+        search_vector: list[float],
+        group_ids: list[str] | None = None,
+        limit=RELEVANT_SCHEMA_LIMIT,
+        min_score=DEFAULT_MIN_SCORE,
 ) -> list[CommunityNode]:
     # vector similarity search over entity names
     records, _, _ = await driver.execute_query(
         """
+                CYPHER runtime = parallel parallelRuntimeSupport=all
                 MATCH (comm:Community)
                 WHERE ($group_ids IS NULL OR comm.group_id IN $group_ids)
+                WITH comm, vector.similarity.cosine(comm.name_embedding, $search_vector) AS score
+                WHERE score > $min_score
                 RETURN
-                    vector.similarity.cosine(comm.name_embedding, $search_vector) AS score,
                     comm.uuid As uuid,
                     comm.group_id AS group_id,
                     comm.name AS name, 
@@ -315,6 +338,7 @@ async def community_similarity_search(
         search_vector=search_vector,
         group_ids=group_ids,
         limit=limit,
+        min_score=min_score,
     )
     communities = [get_community_node_from_record(record) for record in records]
 
@@ -322,11 +346,11 @@ async def community_similarity_search(
 
 
 async def hybrid_node_search(
-    queries: list[str],
-    embeddings: list[list[float]],
-    driver: AsyncDriver,
-    group_ids: list[str] | None = None,
-    limit: int = RELEVANT_SCHEMA_LIMIT,
+        queries: list[str],
+        embeddings: list[list[float]],
+        driver: AsyncDriver,
+        group_ids: list[str] | None = None,
+        limit: int = RELEVANT_SCHEMA_LIMIT,
 ) -> list[EntityNode]:
     """
     Perform a hybrid search for nodes using both text queries and embeddings.
@@ -389,8 +413,8 @@ async def hybrid_node_search(
 
 
 async def get_relevant_nodes(
-    nodes: list[EntityNode],
-    driver: AsyncDriver,
+        nodes: list[EntityNode],
+        driver: AsyncDriver,
 ) -> list[EntityNode]:
     """
     Retrieve relevant nodes based on the provided list of EntityNodes.
@@ -427,11 +451,11 @@ async def get_relevant_nodes(
 
 
 async def get_relevant_edges(
-    driver: AsyncDriver,
-    edges: list[EntityEdge],
-    source_node_uuid: str | None,
-    target_node_uuid: str | None,
-    limit: int = RELEVANT_SCHEMA_LIMIT,
+        driver: AsyncDriver,
+        edges: list[EntityEdge],
+        source_node_uuid: str | None,
+        target_node_uuid: str | None,
+        limit: int = RELEVANT_SCHEMA_LIMIT,
 ) -> list[EntityEdge]:
     start = time()
     relevant_edges: list[EntityEdge] = []
@@ -488,7 +512,7 @@ def rrf(results: list[list[str]], rank_const=1) -> list[str]:
 
 
 async def node_distance_reranker(
-    driver: AsyncDriver, node_uuids: list[str], center_node_uuid: str
+        driver: AsyncDriver, node_uuids: list[str], center_node_uuid: str
 ) -> list[str]:
     # filter out node_uuid center node node uuid
     filtered_uuids = list(filter(lambda uuid: uuid != center_node_uuid, node_uuids))
@@ -555,3 +579,24 @@ async def episode_mentions_reranker(driver: AsyncDriver, node_uuids: list[list[s
     sorted_uuids.sort(key=lambda cur_uuid: scores[cur_uuid])
 
     return sorted_uuids
+
+
+def maximal_marginal_relevance(
+        query_vector: list[float],
+        candidates: list[tuple[str, list[float]]],
+        mmr_lambda: float = DEFAULT_MMR_LAMBDA,
+):
+    candidates_with_mmr: list[tuple[str, float]] = []
+    for candidate in candidates:
+        max_sim = max(
+            [
+                np.dot(normalize_l2(candidate[1]), normalize_l2(c[1]))
+                for c in candidates
+            ]
+        )
+        mmr = mmr_lambda * np.dot(candidate[1], query_vector) + (1 - mmr_lambda) * max_sim
+        candidates_with_mmr.append((candidate[0], mmr))
+
+    candidates_with_mmr.sort(reverse=True, key=lambda c: c[1])
+
+    return [candidate[0] for candidate in candidates_with_mmr]

graphiti_core/utils/maintenance/__init__.py

@@ -4,7 +4,6 @@ from .graph_data_operations import (
     retrieve_episodes,
 )
 from .node_operations import extract_nodes
-from .temporal_operations import invalidate_edges
 
 __all__ = [
     'extract_edges',
@@ -12,5 +11,4 @@ __all__ = [
     'extract_nodes',
     'clear_data',
     'retrieve_episodes',
-    'invalidate_edges',
 ]

graphiti_core/utils/maintenance/community_operations.py

@@ -15,7 +15,6 @@ from graphiti_core.utils.maintenance.edge_operations import build_community_edge
 
 MAX_COMMUNITY_BUILD_CONCURRENCY = 10
 
-
 logger = logging.getLogger(__name__)
 
 
@@ -24,31 +23,20 @@ class Neighbor(BaseModel):
     edge_count: int
 
 
-async def build_community_projection(driver: AsyncDriver) -> str:
-    records, _, _ = await driver.execute_query("""
-    CALL gds.graph.project("communities", "Entity",             
-        {RELATES_TO: {
-            type: "RELATES_TO",
-            orientation: "UNDIRECTED",
-            properties: {weight: {property: "*", aggregation: "COUNT"}}
-        }}
-    )
-    YIELD graphName AS graph, nodeProjection AS nodes, relationshipProjection AS edges
-    """)
-
-    return records[0]['graph']
-
-
-async def get_community_clusters(driver: AsyncDriver) -> list[list[EntityNode]]:
+async def get_community_clusters(
+    driver: AsyncDriver, group_ids: list[str] | None
+) -> list[list[EntityNode]]:
     community_clusters: list[list[EntityNode]] = []
 
-    group_id_values, _, _ = await driver.execute_query("""
-    MATCH (n:Entity WHERE n.group_id IS NOT NULL)
-    RETURN 
-        collect(DISTINCT n.group_id) AS group_ids
-    """)
+    if group_ids is None:
+        group_id_values, _, _ = await driver.execute_query("""
+        MATCH (n:Entity WHERE n.group_id IS NOT NULL)
+        RETURN 
+            collect(DISTINCT n.group_id) AS group_ids
+        """)
+
+        group_ids = group_id_values[0]['group_ids']
 
-    group_ids = group_id_values[0]['group_ids']
     for group_id in group_ids:
         projection: dict[str, list[Neighbor]] = {}
         nodes = await EntityNode.get_by_group_ids(driver, [group_id])
@@ -197,9 +185,9 @@ async def build_community(
 
 
 async def build_communities(
-    driver: AsyncDriver, llm_client: LLMClient
+    driver: AsyncDriver, llm_client: LLMClient, group_ids: list[str] | None
 ) -> tuple[list[CommunityNode], list[CommunityEdge]]:
-    community_clusters = await get_community_clusters(driver)
+    community_clusters = await get_community_clusters(driver, group_ids)
 
     semaphore = asyncio.Semaphore(MAX_COMMUNITY_BUILD_CONCURRENCY)
 

graphiti_core/utils/maintenance/edge_operations.py

@@ -122,12 +122,6 @@ async def extract_edges(
     return edges
 
 
-def create_edge_identifier(
-    source_node: EntityNode, edge: EntityEdge, target_node: EntityNode
-) -> str:
-    return f'{source_node.name}-{edge.name}-{target_node.name}'
-
-
 async def dedupe_extracted_edges(
     llm_client: LLMClient,
     extracted_edges: list[EntityEdge],
@@ -251,11 +245,11 @@ async def resolve_extracted_edge(
         if (
             edge.invalid_at is not None
             and resolved_edge.valid_at is not None
-            and edge.invalid_at < resolved_edge.valid_at
+            and edge.invalid_at <= resolved_edge.valid_at
         ) or (
             edge.valid_at is not None
             and resolved_edge.invalid_at is not None
-            and resolved_edge.invalid_at < edge.valid_at
+            and resolved_edge.invalid_at <= edge.valid_at
         ):
             continue
         # New edge invalidates edge

graphiti_core/utils/maintenance/temporal_operations.py

@@ -21,129 +21,11 @@ from typing import List
 
 from graphiti_core.edges import EntityEdge
 from graphiti_core.llm_client import LLMClient
-from graphiti_core.nodes import EntityNode, EpisodicNode
+from graphiti_core.nodes import EpisodicNode
 from graphiti_core.prompts import prompt_library
 
 logger = logging.getLogger(__name__)
 
-NodeEdgeNodeTriplet = tuple[EntityNode, EntityEdge, EntityNode]
-
-
-def extract_node_and_edge_triplets(
-    edges: list[EntityEdge], nodes: list[EntityNode]
-) -> list[NodeEdgeNodeTriplet]:
-    return [extract_node_edge_node_triplet(edge, nodes) for edge in edges]
-
-
-def extract_node_edge_node_triplet(
-    edge: EntityEdge, nodes: list[EntityNode]
-) -> NodeEdgeNodeTriplet:
-    source_node = next((node for node in nodes if node.uuid == edge.source_node_uuid), None)
-    target_node = next((node for node in nodes if node.uuid == edge.target_node_uuid), None)
-    if not source_node or not target_node:
-        raise ValueError(f'Source or target node not found for edge {edge.uuid}')
-    return (source_node, edge, target_node)
-
-
-def prepare_edges_for_invalidation(
-    existing_edges: list[EntityEdge],
-    new_edges: list[EntityEdge],
-    nodes: list[EntityNode],
-) -> tuple[list[NodeEdgeNodeTriplet], list[NodeEdgeNodeTriplet]]:
-    existing_edges_pending_invalidation: list[NodeEdgeNodeTriplet] = []
-    new_edges_with_nodes: list[NodeEdgeNodeTriplet] = []
-
-    for edge_list, result_list in [
-        (existing_edges, existing_edges_pending_invalidation),
-        (new_edges, new_edges_with_nodes),
-    ]:
-        for edge in edge_list:
-            source_node = next((node for node in nodes if node.uuid == edge.source_node_uuid), None)
-            target_node = next((node for node in nodes if node.uuid == edge.target_node_uuid), None)
-
-            if source_node and target_node:
-                result_list.append((source_node, edge, target_node))
-
-    return existing_edges_pending_invalidation, new_edges_with_nodes
-
-
-async def invalidate_edges(
-    llm_client: LLMClient,
-    existing_edges_pending_invalidation: list[NodeEdgeNodeTriplet],
-    new_edges: list[NodeEdgeNodeTriplet],
-    current_episode: EpisodicNode,
-    previous_episodes: list[EpisodicNode],
-) -> list[EntityEdge]:
-    invalidated_edges = []  # TODO: this is not yet used?
-
-    context = prepare_invalidation_context(
-        existing_edges_pending_invalidation,
-        new_edges,
-        current_episode,
-        previous_episodes,
-    )
-    llm_response = await llm_client.generate_response(prompt_library.invalidate_edges.v1(context))
-
-    edges_to_invalidate = llm_response.get('invalidated_edges', [])
-    invalidated_edges = process_edge_invalidation_llm_response(
-        edges_to_invalidate, existing_edges_pending_invalidation
-    )
-
-    return invalidated_edges
-
-
-def extract_date_strings_from_edge(edge: EntityEdge) -> str:
-    start = edge.valid_at
-    end = edge.invalid_at
-    date_string = f'Start Date: {start.isoformat()}' if start else ''
-    if end:
-        date_string += f' (End Date: {end.isoformat()})'
-    return date_string
-
-
-def prepare_invalidation_context(
-    existing_edges: list[NodeEdgeNodeTriplet],
-    new_edges: list[NodeEdgeNodeTriplet],
-    current_episode: EpisodicNode,
-    previous_episodes: list[EpisodicNode],
-) -> dict:
-    return {
-        'existing_edges': [
-            f'{edge.uuid} | {source_node.name} - {edge.name} - {target_node.name} (Fact: {edge.fact}) {extract_date_strings_from_edge(edge)}'
-            for source_node, edge, target_node in sorted(
-                existing_edges, key=lambda x: (x[1].created_at), reverse=True
-            )
-        ],
-        'new_edges': [
-            f'{edge.uuid} | {source_node.name} - {edge.name} - {target_node.name} (Fact: {edge.fact}) {extract_date_strings_from_edge(edge)}'
-            for source_node, edge, target_node in sorted(
-                new_edges, key=lambda x: (x[1].created_at), reverse=True
-            )
-        ],
-        'current_episode': current_episode.content,
-        'previous_episodes': [episode.content for episode in previous_episodes],
-    }
-
-
-def process_edge_invalidation_llm_response(
-    edges_to_invalidate: List[dict], existing_edges: List[NodeEdgeNodeTriplet]
-) -> List[EntityEdge]:
-    invalidated_edges = []
-    for edge_to_invalidate in edges_to_invalidate:
-        edge_uuid = edge_to_invalidate['edge_uuid']
-        edge_to_update = next(
-            (edge for _, edge, _ in existing_edges if edge.uuid == edge_uuid),
-            None,
-        )
-        if edge_to_update:
-            edge_to_update.expired_at = datetime.now()
-            edge_to_update.fact = edge_to_invalidate['fact']
-            invalidated_edges.append(edge_to_update)
-            logger.info(
-                f"Invalidated edge: {edge_to_update.name} (UUID: {edge_to_update.uuid}). Updated Fact: {edge_to_invalidate['fact']}"
-            )
-    return invalidated_edges
-
 
 async def extract_edge_dates(
     llm_client: LLMClient,
@@ -152,7 +34,6 @@ async def extract_edge_dates(
     previous_episodes: List[EpisodicNode],
 ) -> tuple[datetime | None, datetime | None]:
     context = {
-        'edge_name': edge.name,
         'edge_fact': edge.fact,
         'current_episode': current_episode.content,
         'previous_episodes': [ep.content for ep in previous_episodes],
@@ -162,25 +43,22 @@ async def extract_edge_dates(
 
     valid_at = llm_response.get('valid_at')
     invalid_at = llm_response.get('invalid_at')
-    explanation = llm_response.get('explanation', '')
 
     valid_at_datetime = None
     invalid_at_datetime = None
 
-    if valid_at and valid_at != '':
+    if valid_at:
         try:
             valid_at_datetime = datetime.fromisoformat(valid_at.replace('Z', '+00:00'))
         except ValueError as e:
             logger.error(f'Error parsing valid_at date: {e}. Input: {valid_at}')
 
-    if invalid_at and invalid_at != '':
+    if invalid_at:
         try:
             invalid_at_datetime = datetime.fromisoformat(invalid_at.replace('Z', '+00:00'))
         except ValueError as e:
             logger.error(f'Error parsing invalid_at date: {e}. Input: {invalid_at}')
 
-    logger.info(f'Edge date extraction explanation: {explanation}')
-
     return valid_at_datetime, invalid_at_datetime
 
 

{graphiti_core-0.3.7.dist-info → graphiti_core-0.3.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: graphiti-core
-Version: 0.3.7
+Version: 0.3.9
 Summary: A temporal graph building library
 License: Apache-2.0
 Author: Paul Paliychuk
@@ -14,9 +14,10 @@ Classifier: Programming Language :: Python :: 3.12
 Requires-Dist: diskcache (>=5.6.3,<6.0.0)
 Requires-Dist: neo4j (>=5.23.0,<6.0.0)
 Requires-Dist: numpy (>=1.0.0)
-Requires-Dist: openai (>=1.38.0,<2.0.0)
+Requires-Dist: openai (>=1.50.2,<2.0.0)
 Requires-Dist: pydantic (>=2.8.2,<3.0.0)
 Requires-Dist: tenacity (<9.0.0)
+Requires-Dist: voyageai (>=0.2.3,<0.3.0)
 Description-Content-Type: text/markdown
 
 <div align="center">

{graphiti_core-0.3.7.dist-info → graphiti_core-0.3.9.dist-info}/RECORD

@@ -1,12 +1,12 @@
 graphiti_core/__init__.py,sha256=e5SWFkRiaUwfprYIeIgVIh7JDedNiloZvd3roU-0aDY,55
-graphiti_core/edges.py,sha256=lLuRKjSHTk1GvTS06OUw2lSMiDAB4TQSXgnLq1fU3n8,13378
+graphiti_core/edges.py,sha256=IKWe6nRxg749RD7o5AgbbH6blCPBtNREBRSU_oMt4tM,13434
 graphiti_core/embedder/__init__.py,sha256=eWd-0sPxflnYXLoWNT9sxwCIFun5JNO9Fk4E-ZXXf8Y,164
 graphiti_core/embedder/client.py,sha256=Sd9CyYXaqRazdOH8opKackrTx-y9y-T54M78XTVMzxs,1006
-graphiti_core/embedder/openai.py,sha256=28cl4qQCQeu6EGxVVPw3lPesA-Z_Cpvuhozyc1jdqVg,1586
-graphiti_core/embedder/voyage.py,sha256=pGrSquGnSiYl4nXGnutbdWchtYgZb0Fi_yW3c90dPlI,1497
+graphiti_core/embedder/openai.py,sha256=_FVpmdgEBgbeXGQjivhiA7qxEUuDNwCxI_l-2k_95QA,1590
+graphiti_core/embedder/voyage.py,sha256=jLf43hIzeAnSZSy0P4jitVacWLYiKn3o8qZ9w10-r6E,1501
 graphiti_core/errors.py,sha256=iJrkk5sTgc2z16ABS6TziPylEabdBJcpk0x9KyBUmxs,1527
-graphiti_core/graphiti.py,sha256=5E2UbYlbl65D3MZyagEUPgoPrb_kVYDIqIw7KVlU_NM,26162
-graphiti_core/helpers.py,sha256=_wTSDcYmeXT3u0AwX15iSLuTRa_SR4jJdT10rxfl1_E,1484
+graphiti_core/graphiti.py,sha256=a4ECdZ9-Zx-KxCctIKLnrLBnpgdwTu6jm0DlyDJLnpk,26936
+graphiti_core/helpers.py,sha256=gS0BU5OOL1S6ByV2ogFlGpBiryyBHyM3ZnLSukbl6_4,1996
 graphiti_core/llm_client/__init__.py,sha256=PA80TSMeX-sUXITXEAxMDEt3gtfZgcJrGJUcyds1mSo,207
 graphiti_core/llm_client/anthropic_client.py,sha256=4l2PbCjIoeRr7UJ2DUh2grYLTtE2vNaWlo72IIRQDeI,2405
 graphiti_core/llm_client/client.py,sha256=WAnX0e4EuCFHXdFHeq_O1HZsW1STSByvDCFUHMAHEFU,3394
@@ -15,34 +15,34 @@ graphiti_core/llm_client/errors.py,sha256=-qlWwv1X-UjfsFIiNl-7yJIYvPwi7z8srVRfX4
 graphiti_core/llm_client/groq_client.py,sha256=5uGWeQ903EuNxuRiaeH-_J1U2Le_b7Q1UGV_K8bQAiw,2329
 graphiti_core/llm_client/openai_client.py,sha256=xLkbpusRVFRK0zPr3kOqY31HK_XCXrpO5rqUSpcEqEU,3825
 graphiti_core/llm_client/utils.py,sha256=Ms-QhA5X9rps7NBdJeQZUgQLD3vaZRWPiTlhJa6BjXM,995
-graphiti_core/nodes.py,sha256=wIYeRspoRErcX0vvesk_fxhdXKCYn4rpgjgm3PdwSkI,13669
+graphiti_core/nodes.py,sha256=Jcn9LFr22NHVvyh0eSqUk_zTSY0dU3192MRKPUPSR4c,13783
 graphiti_core/prompts/__init__.py,sha256=EA-x9xUki9l8wnu2l8ek_oNf75-do5tq5hVq7Zbv8Kw,101
 graphiti_core/prompts/dedupe_edges.py,sha256=DUNHdIudj50FAjkla4nc68tSFSD2yjmYHBw-Bb7ph20,6529
 graphiti_core/prompts/dedupe_nodes.py,sha256=BZ9S-PB9SSGjc5Oo8ivdgA6rZx3OGOFhKtwrBlQ0bm0,7269
-graphiti_core/prompts/eval.py,sha256=fYLY2nKwgE9dB7mtYMNKyn1tQXM8B-tOeYmSzB5Bxk8,2844
-graphiti_core/prompts/extract_edge_dates.py,sha256=oOCR8mC_3gI1bumrmIjUbkNO-WTuLTXXAalPDYnDXeM,3655
-graphiti_core/prompts/extract_edges.py,sha256=AQ8xYbAv_RKXAT6WMwXs1_GvUdLtM_lhLNbt3SkOAmk,5348
+graphiti_core/prompts/eval.py,sha256=9gavc4SKAPdsrhpN8NEUTc632erkaifyOf0hevmdeKY,3657
+graphiti_core/prompts/extract_edge_dates.py,sha256=pb5Oe5WTZ468REmWNR2NAEHHYMt5GpiJVUAqpVI3aBI,3622
+graphiti_core/prompts/extract_edges.py,sha256=pGmYcl1zKIuu-HmHUkbkThJ5QKED3efMtDlKoT0wBRM,5448
 graphiti_core/prompts/extract_nodes.py,sha256=VIr0Nh0mSiodI3iGOQFszh7DOni4mufOKJDuGkMysl8,6889
-graphiti_core/prompts/invalidate_edges.py,sha256=8SHt3iPTdmqk8A52LxgdMtI39w4USKqVDMOS2i6lRQ4,4342
+graphiti_core/prompts/invalidate_edges.py,sha256=2vhi9TsL9poAHqApfk_Us0VveG0-T8cZymfBwOgA8tc,4341
 graphiti_core/prompts/lib.py,sha256=ZOE6nNoI_wQ12Sufx7rQkQtkIm_eTAL7pCiYGU2hcMI,4054
 graphiti_core/prompts/models.py,sha256=cvx_Bv5RMFUD_5IUawYrbpOKLPHogai7_bm7YXrSz84,867
 graphiti_core/prompts/summarize_nodes.py,sha256=FLuZpGTABgcxuIDkx_IKH115nHEw0rIaFhcGlWveAMc,2357
 graphiti_core/py.typed,sha256=vlmmzQOt7bmeQl9L3XJP4W6Ry0iiELepnOrinKz5KQg,79
 graphiti_core/search/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-graphiti_core/search/search.py,sha256=odxpm6MJw5ihEDjbBQ2Icvtr5Mf2oG8Yj6LpNqO3gFw,8620
-graphiti_core/search/search_config.py,sha256=d8w9RDO55G2bwbjYQBaD6gXqEWK1-NsDANrNibYB6t8,2165
-graphiti_core/search/search_config_recipes.py,sha256=_VJqvYB70e8Jke3hsbeQF3Bdogn2MubpYeAQe15M2Jo,3450
-graphiti_core/search/search_utils.py,sha256=WE-iVPI92AWR13aM3JQxtHaYoiPzDMtOOo8rEob8QEI,17844
+graphiti_core/search/search.py,sha256=bFCHscRU4V_blPlvuoM4ugRUdeZ6smGAnTMaQulvcjU,9024
+graphiti_core/search/search_config.py,sha256=dWcanEmMoL42RHF-jcZO9C2G9BdqjkI9w-5xe9Wd2Xg,2737
+graphiti_core/search/search_config_recipes.py,sha256=8kr3oeXQG4L_j1IrceOVeE7IGNtUSLTSe3p89-NGwWM,4892
+graphiti_core/search/search_utils.py,sha256=dJ5vYC0U7JyjlritDSNPY3bbFyDqwuV0fDnOZ7H37hk,19421
 graphiti_core/utils/__init__.py,sha256=cJAcMnBZdHBQmWrZdU1PQ1YmaL75bhVUkyVpIPuOyns,260
 graphiti_core/utils/bulk_utils.py,sha256=JtoYTZPCigPa3n2E43Oe7QhFZRTA_QKNGy1jVgklHag,12614
-graphiti_core/utils/maintenance/__init__.py,sha256=4b9sfxqyFZMLwxxS2lnQ6_wBr3xrJRIqfAWOidK8EK0,388
-graphiti_core/utils/maintenance/community_operations.py,sha256=Z2lVrTmUh42sEPqSDZq4fXbcj507BuZrHZKV1vJk6tU,9875
-graphiti_core/utils/maintenance/edge_operations.py,sha256=lSeesSnWQ3vpeD2dIY0tSiHEHRMK6fiirEhNNT-s5os,11438
+graphiti_core/utils/maintenance/__init__.py,sha256=TRY3wWWu5kn3Oahk_KKhltrWnh0NACw0FskjqF6OtlA,314
+graphiti_core/utils/maintenance/community_operations.py,sha256=BiL2LTuGSbyZNg65FmgeZ3HSfAl3OuWgbmMlsSoQgk4,9505
+graphiti_core/utils/maintenance/edge_operations.py,sha256=rlB88mQ5WFr1gcSefdUuACLP_mwRbnFohbdJwnh03uo,11265
 graphiti_core/utils/maintenance/graph_data_operations.py,sha256=RgdqYSau9Mr-f7IUSD1sSPztxlyO0C80C3MPPmPBRi0,6100
 graphiti_core/utils/maintenance/node_operations.py,sha256=QAg4KQkSAOXx9QRaUp7t6DCaztZlzeOBC3__57FCs_o,9025
-graphiti_core/utils/maintenance/temporal_operations.py,sha256=BzfGDm96w4HcUEsaWTHUBt5S8dNmDQL1eX6AuBL-XFM,8135
+graphiti_core/utils/maintenance/temporal_operations.py,sha256=wWLSWqcB3AQWs0YFiVH6avP7RC6Zy_Bua7dBLeUX_V4,3366
 graphiti_core/utils/maintenance/utils.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-graphiti_core-0.3.7.dist-info/LICENSE,sha256=KCUwCyDXuVEgmDWkozHyniRyWjnWUWjkuDHfU6o3JlA,11325
-graphiti_core-0.3.7.dist-info/METADATA,sha256=6NPJcK3qV8rcVDjopZyTqyc8WlcFXKYDVEOdOzco1KI,9395
-graphiti_core-0.3.7.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-graphiti_core-0.3.7.dist-info/RECORD,,
+graphiti_core-0.3.9.dist-info/LICENSE,sha256=KCUwCyDXuVEgmDWkozHyniRyWjnWUWjkuDHfU6o3JlA,11325
+graphiti_core-0.3.9.dist-info/METADATA,sha256=leK_2yXwo_vRcQeTVS8F3awiQUbaIQJ0m4TH9RG656o,9436
+graphiti_core-0.3.9.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+graphiti_core-0.3.9.dist-info/RECORD,,