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

graphiti_core/edges.py

@@ -24,9 +24,9 @@ from uuid import uuid4
 from neo4j import AsyncDriver
 from pydantic import BaseModel, Field
 
+from graphiti_core.embedder import EmbedderClient
 from graphiti_core.errors import EdgeNotFoundError, GroupsEdgesNotFoundError
 from graphiti_core.helpers import parse_db_date
-from graphiti_core.llm_client.config import EMBEDDING_DIM
 from graphiti_core.nodes import Node
 
 logger = logging.getLogger(__name__)
@@ -171,17 +171,16 @@ class EntityEdge(Edge):
         default=None, description='datetime of when the fact stopped being true'
     )
 
-    async def generate_embedding(self, embedder, model='text-embedding-3-small'):
+    async def generate_embedding(self, embedder: EmbedderClient):
         start = time()
 
         text = self.fact.replace('\n', ' ')
-        embedding = (await embedder.create(input=[text], model=model)).data[0].embedding
-        self.fact_embedding = embedding[:EMBEDDING_DIM]
+        self.fact_embedding = await embedder.create(input=[text])
 
         end = time()
         logger.info(f'embedded {text} in {end - start} ms')
 
-        return embedding
+        return self.fact_embedding
 
     async def save(self, driver: AsyncDriver):
         result = await driver.execute_query(

graphiti_core/embedder/__init__.py

@@ -0,0 +1,4 @@
+from .client import EmbedderClient
+from .openai import OpenAIEmbedder, OpenAIEmbedderConfig
+
+__all__ = ['EmbedderClient', 'OpenAIEmbedder', 'OpenAIEmbedderConfig']

graphiti_core/embedder/client.py

@@ -0,0 +1,34 @@
+"""
+Copyright 2024, Zep Software, Inc.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+from abc import ABC, abstractmethod
+from typing import Iterable, List, Literal
+
+from pydantic import BaseModel, Field
+
+EMBEDDING_DIM = 1024
+
+
+class EmbedderConfig(BaseModel):
+    embedding_dim: Literal[1024] = Field(default=EMBEDDING_DIM, frozen=True)
+
+
+class EmbedderClient(ABC):
+    @abstractmethod
+    async def create(
+        self, input: str | List[str] | Iterable[int] | Iterable[Iterable[int]]
+    ) -> list[float]:
+        pass

graphiti_core/embedder/openai.py

@@ -0,0 +1,48 @@
+"""
+Copyright 2024, Zep Software, Inc.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+from typing import Iterable, List
+
+from openai import AsyncOpenAI
+from openai.types import EmbeddingModel
+
+from .client import EmbedderClient, EmbedderConfig
+
+DEFAULT_EMBEDDING_MODEL = 'text-embedding-3-small'
+
+
+class OpenAIEmbedderConfig(EmbedderConfig):
+    embedding_model: EmbeddingModel | str = DEFAULT_EMBEDDING_MODEL
+    api_key: str | None = None
+    base_url: str | None = None
+
+
+class OpenAIEmbedder(EmbedderClient):
+    """
+    OpenAI Embedder Client
+    """
+
+    def __init__(self, config: OpenAIEmbedderConfig | None = None):
+        if config is None:
+            config = OpenAIEmbedderConfig()
+        self.config = config
+        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]]
+    ) -> 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

@@ -0,0 +1,47 @@
+"""
+Copyright 2024, Zep Software, Inc.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+from typing import Iterable, List
+
+import voyageai  # type: ignore
+from pydantic import Field
+
+from .client import EmbedderClient, EmbedderConfig
+
+DEFAULT_EMBEDDING_MODEL = 'voyage-3'
+
+
+class VoyageAIEmbedderConfig(EmbedderConfig):
+    embedding_model: str = Field(default=DEFAULT_EMBEDDING_MODEL)
+    api_key: str | None = None
+
+
+class VoyageAIEmbedder(EmbedderClient):
+    """
+    VoyageAI Embedder Client
+    """
+
+    def __init__(self, config: VoyageAIEmbedderConfig | None = None):
+        if config is None:
+            config = VoyageAIEmbedderConfig()
+        self.config = config
+        self.client = voyageai.AsyncClient(api_key=config.api_key)
+
+    async def create(
+        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

@@ -23,6 +23,7 @@ from dotenv import load_dotenv
 from neo4j import AsyncGraphDatabase
 
 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.search.search import SearchConfig, search
@@ -83,6 +84,7 @@ class Graphiti:
         user: str,
         password: str,
         llm_client: LLMClient | None = None,
+        embedder: EmbedderClient | None = None,
         store_raw_episode_content: bool = True,
     ):
         """
@@ -128,6 +130,10 @@ class Graphiti:
             self.llm_client = llm_client
         else:
             self.llm_client = OpenAIClient()
+        if embedder:
+            self.embedder = embedder
+        else:
+            self.embedder = OpenAIEmbedder()
 
     async def close(self):
         """
@@ -161,7 +167,7 @@ class Graphiti:
         """
         await self.driver.close()
 
-    async def build_indices_and_constraints(self):
+    async def build_indices_and_constraints(self, delete_existing: bool = False):
         """
         Build indices and constraints in the Neo4j database.
 
@@ -171,6 +177,9 @@ class Graphiti:
         Parameters
         ----------
         self
+        delete_existing : bool, optional
+            Whether to clear existing indices before creating new ones.
+
 
         Returns
         -------
@@ -191,7 +200,7 @@ class Graphiti:
         Caution: Running this method on a large existing database may take some time
         and could impact database performance during execution.
         """
-        await build_indices_and_constraints(self.driver)
+        await build_indices_and_constraints(self.driver, delete_existing)
 
     async def retrieve_episodes(
         self,
@@ -287,7 +296,6 @@ class Graphiti:
             start = time()
 
             entity_edges: list[EntityEdge] = []
-            embedder = self.llm_client.get_embedder()
             now = datetime.now()
 
             previous_episodes = await self.retrieve_episodes(
@@ -315,7 +323,7 @@ class Graphiti:
             # Calculate Embeddings
 
             await asyncio.gather(
-                *[node.generate_name_embedding(embedder) for node in extracted_nodes]
+                *[node.generate_name_embedding(self.embedder) for node in extracted_nodes]
             )
 
             # Resolve extracted nodes with nodes already in the graph and extract facts
@@ -343,7 +351,7 @@ class Graphiti:
             # calculate embeddings
             await asyncio.gather(
                 *[
-                    edge.generate_embedding(embedder)
+                    edge.generate_embedding(self.embedder)
                     for edge in extracted_edges_with_resolved_pointers
                 ]
             )
@@ -436,7 +444,7 @@ class Graphiti:
             if update_communities:
                 await asyncio.gather(
                     *[
-                        update_community(self.driver, self.llm_client, embedder, node)
+                        update_community(self.driver, self.llm_client, self.embedder, node)
                         for node in nodes
                     ]
                 )
@@ -485,7 +493,6 @@ class Graphiti:
         """
         try:
             start = time()
-            embedder = self.llm_client.get_embedder()
             now = datetime.now()
 
             episodes = [
@@ -517,8 +524,8 @@ class Graphiti:
 
             # Generate embeddings
             await asyncio.gather(
-                *[node.generate_name_embedding(embedder) for node in extracted_nodes],
-                *[edge.generate_embedding(embedder) for edge in extracted_edges],
+                *[node.generate_name_embedding(self.embedder) for node in extracted_nodes],
+                *[edge.generate_embedding(self.embedder) for edge in extracted_edges],
             )
 
             # Dedupe extracted nodes, compress extracted edges
@@ -561,14 +568,14 @@ class Graphiti:
             raise e
 
     async def build_communities(self):
-        embedder = self.llm_client.get_embedder()
-
         # Clear existing communities
         await remove_communities(self.driver)
 
         community_nodes, community_edges = await build_communities(self.driver, self.llm_client)
 
-        await asyncio.gather(*[node.generate_name_embedding(embedder) for node in community_nodes])
+        await asyncio.gather(
+            *[node.generate_name_embedding(self.embedder) for node in community_nodes]
+        )
 
         await asyncio.gather(*[node.save(self.driver) for node in community_nodes])
         await asyncio.gather(*[edge.save(self.driver) for edge in community_edges])
@@ -619,7 +626,7 @@ class Graphiti:
         edges = (
             await search(
                 self.driver,
-                self.llm_client.get_embedder(),
+                self.embedder,
                 query,
                 group_ids,
                 search_config,
@@ -636,9 +643,7 @@ class Graphiti:
         group_ids: list[str] | None = None,
         center_node_uuid: str | None = None,
     ) -> SearchResults:
-        return await search(
-            self.driver, self.llm_client.get_embedder(), query, group_ids, config, center_node_uuid
-        )
+        return await search(self.driver, self.embedder, query, group_ids, config, center_node_uuid)
 
     async def get_nodes_by_query(
         self,
@@ -683,14 +688,15 @@ class Graphiti:
         to each individual search method before results are combined and deduplicated.
         If not specified, a default limit (defined in the search functions) will be used.
         """
-        embedder = self.llm_client.get_embedder()
         search_config = (
             NODE_HYBRID_SEARCH_RRF if center_node_uuid is None else NODE_HYBRID_SEARCH_NODE_DISTANCE
         )
         search_config.limit = limit
 
         nodes = (
-            await search(self.driver, embedder, query, group_ids, search_config, center_node_uuid)
+            await search(
+                self.driver, self.embedder, query, group_ids, search_config, center_node_uuid
+            )
         ).nodes
         return nodes
 

graphiti_core/helpers.py

@@ -21,3 +21,33 @@ from neo4j import time as neo4j_time
 
 def parse_db_date(neo_date: neo4j_time.DateTime | None) -> datetime | None:
     return neo_date.to_native() if neo_date else None
+
+
+def lucene_sanitize(query: str) -> str:
+    # Escape special characters from a query before passing into Lucene
+    # + - && || ! ( ) { } [ ] ^ " ~ * ? : \
+    escape_map = str.maketrans(
+        {
+            '+': r'\+',
+            '-': r'\-',
+            '&': r'\&',
+            '|': r'\|',
+            '!': r'\!',
+            '(': r'\(',
+            ')': r'\)',
+            '{': r'\{',
+            '}': r'\}',
+            '[': r'\[',
+            ']': r'\]',
+            '^': r'\^',
+            '"': r'\"',
+            '~': r'\~',
+            '*': r'\*',
+            '?': r'\?',
+            ':': r'\:',
+            '\\': r'\\',
+        }
+    )
+
+    sanitized = query.translate(escape_map)
+    return sanitized

graphiti_core/llm_client/anthropic_client.py

@@ -20,7 +20,6 @@ import typing
 
 import anthropic
 from anthropic import AsyncAnthropic
-from openai import AsyncOpenAI
 
 from ..prompts.models import Message
 from .client import LLMClient
@@ -47,10 +46,6 @@ class AnthropicClient(LLMClient):
             max_retries=1,
         )
 
-    def get_embedder(self) -> typing.Any:
-        openai_client = AsyncOpenAI()
-        return openai_client.embeddings
-
     async def _generate_response(self, messages: list[Message]) -> dict[str, typing.Any]:
         system_message = messages[0]
         user_messages = [{'role': m.role, 'content': m.content} for m in messages[1:]] + [

graphiti_core/llm_client/client.py

@@ -55,10 +55,6 @@ class LLMClient(ABC):
         self.cache_enabled = cache
         self.cache_dir = Cache(DEFAULT_CACHE_DIR)  # Create a cache directory
 
-    @abstractmethod
-    def get_embedder(self) -> typing.Any:
-        pass
-
     @retry(
         stop=stop_after_attempt(4),
         wait=wait_random_exponential(multiplier=10, min=5, max=120),

graphiti_core/llm_client/config.py

@@ -14,7 +14,6 @@ See the License for the specific language governing permissions and
 limitations under the License.
 """
 
-EMBEDDING_DIM = 1024
 DEFAULT_MAX_TOKENS = 16384
 DEFAULT_TEMPERATURE = 0
 

graphiti_core/llm_client/groq_client.py

@@ -21,7 +21,6 @@ import typing
 import groq
 from groq import AsyncGroq
 from groq.types.chat import ChatCompletionMessageParam
-from openai import AsyncOpenAI
 
 from ..prompts.models import Message
 from .client import LLMClient
@@ -44,10 +43,6 @@ class GroqClient(LLMClient):
 
         self.client = AsyncGroq(api_key=config.api_key)
 
-    def get_embedder(self) -> typing.Any:
-        openai_client = AsyncOpenAI()
-        return openai_client.embeddings
-
     async def _generate_response(self, messages: list[Message]) -> dict[str, typing.Any]:
         msgs: list[ChatCompletionMessageParam] = []
         for m in messages:

graphiti_core/llm_client/openai_client.py

@@ -49,9 +49,6 @@ class OpenAIClient(LLMClient):
         __init__(config: LLMConfig | None = None, cache: bool = False, client: typing.Any = None):
             Initializes the OpenAIClient with the provided configuration, cache setting, and client.
 
-        get_embedder() -> typing.Any:
-            Returns the embedder from the OpenAI client.
-
         _generate_response(messages: list[Message]) -> dict[str, typing.Any]:
             Generates a response from the language model based on the provided messages.
     """
@@ -78,9 +75,6 @@ class OpenAIClient(LLMClient):
         else:
             self.client = client
 
-    def get_embedder(self) -> typing.Any:
-        return self.client.embeddings
-
     async def _generate_response(self, messages: list[Message]) -> dict[str, typing.Any]:
         openai_messages: list[ChatCompletionMessageParam] = []
         for m in messages:

graphiti_core/llm_client/utils.py

@@ -15,22 +15,18 @@ limitations under the License.
 """
 
 import logging
-import typing
 from time import time
 
-from graphiti_core.llm_client.config import EMBEDDING_DIM
+from graphiti_core.embedder.client import EmbedderClient
 
 logger = logging.getLogger(__name__)
 
 
-async def generate_embedding(
-    embedder: typing.Any, text: str, model: str = 'text-embedding-3-small'
-):
+async def generate_embedding(embedder: EmbedderClient, text: str):
     start = time()
 
     text = text.replace('\n', ' ')
-    embedding = (await embedder.create(input=[text], model=model)).data[0].embedding
-    embedding = embedding[:EMBEDDING_DIM]
+    embedding = await embedder.create(input=[text])
 
     end = time()
     logger.debug(f'embedded text of length {len(text)} in {end - start} ms')

graphiti_core/nodes.py

@@ -25,8 +25,8 @@ from uuid import uuid4
 from neo4j import AsyncDriver
 from pydantic import BaseModel, Field
 
+from graphiti_core.embedder import EmbedderClient
 from graphiti_core.errors import NodeNotFoundError
-from graphiti_core.llm_client.config import EMBEDDING_DIM
 
 logger = logging.getLogger(__name__)
 
@@ -212,15 +212,14 @@ class EntityNode(Node):
     name_embedding: list[float] | None = Field(default=None, description='embedding of the name')
     summary: str = Field(description='regional summary of surrounding edges', default_factory=str)
 
-    async def generate_name_embedding(self, embedder, model='text-embedding-3-small'):
+    async def generate_name_embedding(self, embedder: EmbedderClient):
         start = time()
         text = self.name.replace('\n', ' ')
-        embedding = (await embedder.create(input=[text], model=model)).data[0].embedding
-        self.name_embedding = embedding[:EMBEDDING_DIM]
+        self.name_embedding = await embedder.create(input=[text])
         end = time()
         logger.info(f'embedded {text} in {end - start} ms')
 
-        return embedding
+        return self.name_embedding
 
     async def save(self, driver: AsyncDriver):
         result = await driver.execute_query(
@@ -323,15 +322,14 @@ class CommunityNode(Node):
 
         return result
 
-    async def generate_name_embedding(self, embedder, model='text-embedding-3-small'):
+    async def generate_name_embedding(self, embedder: EmbedderClient):
         start = time()
         text = self.name.replace('\n', ' ')
-        embedding = (await embedder.create(input=[text], model=model)).data[0].embedding
-        self.name_embedding = embedding[:EMBEDDING_DIM]
+        self.name_embedding = await embedder.create(input=[text])
         end = time()
         logger.info(f'embedded {text} in {end - start} ms')
 
-        return embedding
+        return self.name_embedding
 
     @classmethod
     async def get_by_uuid(cls, driver: AsyncDriver, uuid: str):

graphiti_core/prompts/eval.py

@@ -0,0 +1,90 @@
+"""
+Copyright 2024, Zep Software, Inc.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+import json
+from typing import Any, Protocol, TypedDict
+
+from .models import Message, PromptFunction, PromptVersion
+
+
+class Prompt(Protocol):
+    qa_prompt: PromptVersion
+    eval_prompt: PromptVersion
+
+
+class Versions(TypedDict):
+    qa_prompt: PromptFunction
+    eval_prompt: PromptFunction
+
+
+def qa_prompt(context: dict[str, Any]) -> list[Message]:
+    sys_prompt = """You are Alice and should respond to all questions from the first person perspective of Alice"""
+
+    user_prompt = f"""
+    Your task is to briefly answer the question in the way that you think Alice would answer the question.
+    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
+    <FACTS>
+    {json.dumps(context['facts'])}
+    </FACTS>
+    <QUESTION>
+    {context['query']}
+    </QUESTION>
+    respond with a JSON object in the following format:
+    {{
+        "ANSWER": "how Alice would answer the question"
+    }}
+    """
+    return [
+        Message(role='system', content=sys_prompt),
+        Message(role='user', content=user_prompt),
+    ]
+
+
+def eval_prompt(context: dict[str, Any]) -> list[Message]:
+    sys_prompt = (
+        """You are a judge that determines if answers to questions match a gold standard answer"""
+    )
+
+    user_prompt = f"""
+    Given the QUESTION and the gold standard ANSWER determine if the RESPONSE to the question is correct or incorrect.
+    Although the RESPONSE may be more verbose, mark it as correct as long as it references the same topic 
+    as the gold standard ANSWER. Also include your reasoning for the grade.
+    <QUESTION>
+    {context['query']}
+    </QUESTION>
+    <ANSWER>
+    {context['answer']}
+    </ANSWER>
+    <RESPONSE>
+    {context['response']}
+    </RESPONSE>
+    
+    respond with a JSON object in the following format:
+    {{
+        "is_correct": "boolean if the answer is correct or incorrect"
+        "reasoning": "why you determined the response was correct or incorrect"
+    }}
+    """
+    return [
+        Message(role='system', content=sys_prompt),
+        Message(role='user', content=user_prompt),
+    ]
+
+
+versions: Versions = {'qa_prompt': qa_prompt, 'eval_prompt': eval_prompt}

graphiti_core/prompts/lib.py

@@ -34,6 +34,9 @@ from .dedupe_nodes import (
 from .dedupe_nodes import (
     versions as dedupe_nodes_versions,
 )
+from .eval import Prompt as EvalPrompt
+from .eval import Versions as EvalVersions
+from .eval import versions as eval_versions
 from .extract_edge_dates import (
     Prompt as ExtractEdgeDatesPrompt,
 )
@@ -84,6 +87,7 @@ class PromptLibrary(Protocol):
     invalidate_edges: InvalidateEdgesPrompt
     extract_edge_dates: ExtractEdgeDatesPrompt
     summarize_nodes: SummarizeNodesPrompt
+    eval: EvalPrompt
 
 
 class PromptLibraryImpl(TypedDict):
@@ -94,6 +98,7 @@ class PromptLibraryImpl(TypedDict):
     invalidate_edges: InvalidateEdgesVersions
     extract_edge_dates: ExtractEdgeDatesVersions
     summarize_nodes: SummarizeNodesVersions
+    eval: EvalVersions
 
 
 class VersionWrapper:
@@ -124,5 +129,6 @@ PROMPT_LIBRARY_IMPL: PromptLibraryImpl = {
     'invalidate_edges': invalidate_edges_versions,
     'extract_edge_dates': extract_edge_dates_versions,
     'summarize_nodes': summarize_nodes_versions,
+    'eval': eval_versions,
 }
 prompt_library: PromptLibrary = PromptLibraryWrapper(PROMPT_LIBRARY_IMPL)  # type: ignore[assignment]

graphiti_core/search/search.py

@@ -14,6 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 """
 
+import asyncio
 import logging
 from collections import defaultdict
 from time import time
@@ -21,8 +22,8 @@ from time import time
 from neo4j import AsyncDriver
 
 from graphiti_core.edges import EntityEdge
+from graphiti_core.embedder import EmbedderClient
 from graphiti_core.errors import SearchRerankerError
-from graphiti_core.llm_client.config import EMBEDDING_DIM
 from graphiti_core.nodes import CommunityNode, EntityNode
 from graphiti_core.search.search_config import (
     DEFAULT_SEARCH_LIMIT,
@@ -55,7 +56,7 @@ logger = logging.getLogger(__name__)
 
 async def search(
     driver: AsyncDriver,
-    embedder,
+    embedder: EmbedderClient,
     query: str,
     group_ids: list[str] | None,
     config: SearchConfig,
@@ -65,32 +66,39 @@ async def search(
     query = query.replace('\n', ' ')
     # if group_ids is empty, set it to None
     group_ids = group_ids if group_ids else None
-    edges = (
-        await edge_search(
-            driver, embedder, query, group_ids, config.edge_config, center_node_uuid, config.limit
-        )
-        if config.edge_config is not None
-        else []
-    )
-    nodes = (
-        await node_search(
-            driver, embedder, query, group_ids, config.node_config, center_node_uuid, config.limit
-        )
-        if config.node_config is not None
-        else []
-    )
-    communities = (
-        await community_search(
-            driver, embedder, query, group_ids, config.community_config, config.limit
-        )
-        if config.community_config is not None
-        else []
+    edges, nodes, communities = await asyncio.gather(
+        edge_search(
+            driver,
+            embedder,
+            query,
+            group_ids,
+            config.edge_config,
+            center_node_uuid,
+            config.limit,
+        ),
+        node_search(
+            driver,
+            embedder,
+            query,
+            group_ids,
+            config.node_config,
+            center_node_uuid,
+            config.limit,
+        ),
+        community_search(
+            driver,
+            embedder,
+            query,
+            group_ids,
+            config.community_config,
+            config.limit,
+        ),
     )
 
     results = SearchResults(
-        edges=edges[: config.limit],
-        nodes=nodes[: config.limit],
-        communities=communities[: config.limit],
+        edges=edges,
+        nodes=nodes,
+        communities=communities,
     )
 
     end = time()
@@ -102,13 +110,16 @@ async def search(
 
 async def edge_search(
     driver: AsyncDriver,
-    embedder,
+    embedder: EmbedderClient,
     query: str,
     group_ids: list[str] | None,
-    config: EdgeSearchConfig,
+    config: EdgeSearchConfig | None,
     center_node_uuid: str | None = None,
     limit=DEFAULT_SEARCH_LIMIT,
 ) -> list[EntityEdge]:
+    if config is None:
+        return []
+
     search_results: list[list[EntityEdge]] = []
 
     if EdgeSearchMethod.bm25 in config.search_methods:
@@ -116,11 +127,7 @@ async def edge_search(
         search_results.append(text_search)
 
     if EdgeSearchMethod.cosine_similarity in config.search_methods:
-        search_vector = (
-            (await embedder.create(input=[query], model='text-embedding-3-small'))
-            .data[0]
-            .embedding[:EMBEDDING_DIM]
-        )
+        search_vector = await embedder.create(input=[query])
 
         similarity_search = await edge_similarity_search(
             driver, search_vector, None, None, group_ids, 2 * limit
@@ -162,18 +169,21 @@ async def edge_search(
     if config.reranker == EdgeReranker.episode_mentions:
         reranked_edges.sort(reverse=True, key=lambda edge: len(edge.episodes))
 
-    return reranked_edges
+    return reranked_edges[:limit]
 
 
 async def node_search(
     driver: AsyncDriver,
-    embedder,
+    embedder: EmbedderClient,
     query: str,
     group_ids: list[str] | None,
-    config: NodeSearchConfig,
+    config: NodeSearchConfig | None,
     center_node_uuid: str | None = None,
     limit=DEFAULT_SEARCH_LIMIT,
 ) -> list[EntityNode]:
+    if config is None:
+        return []
+
     search_results: list[list[EntityNode]] = []
 
     if NodeSearchMethod.bm25 in config.search_methods:
@@ -181,11 +191,7 @@ async def node_search(
         search_results.append(text_search)
 
     if NodeSearchMethod.cosine_similarity in config.search_methods:
-        search_vector = (
-            (await embedder.create(input=[query], model='text-embedding-3-small'))
-            .data[0]
-            .embedding[:EMBEDDING_DIM]
-        )
+        search_vector = await embedder.create(input=[query])
 
         similarity_search = await node_similarity_search(
             driver, search_vector, group_ids, 2 * limit
@@ -212,17 +218,20 @@ async def node_search(
 
     reranked_nodes = [node_uuid_map[uuid] for uuid in reranked_uuids]
 
-    return reranked_nodes
+    return reranked_nodes[:limit]
 
 
 async def community_search(
     driver: AsyncDriver,
-    embedder,
+    embedder: EmbedderClient,
     query: str,
     group_ids: list[str] | None,
-    config: CommunitySearchConfig,
+    config: CommunitySearchConfig | None,
     limit=DEFAULT_SEARCH_LIMIT,
 ) -> list[CommunityNode]:
+    if config is None:
+        return []
+
     search_results: list[list[CommunityNode]] = []
 
     if CommunitySearchMethod.bm25 in config.search_methods:
@@ -230,11 +239,7 @@ async def community_search(
         search_results.append(text_search)
 
     if CommunitySearchMethod.cosine_similarity in config.search_methods:
-        search_vector = (
-            (await embedder.create(input=[query], model='text-embedding-3-small'))
-            .data[0]
-            .embedding[:EMBEDDING_DIM]
-        )
+        search_vector = await embedder.create(input=[query])
 
         similarity_search = await community_similarity_search(
             driver, search_vector, group_ids, 2 * limit
@@ -255,4 +260,4 @@ async def community_search(
 
     reranked_communities = [community_uuid_map[uuid] for uuid in reranked_uuids]
 
-    return reranked_communities
+    return reranked_communities[:limit]

graphiti_core/search/search_utils.py

@@ -16,13 +16,13 @@ limitations under the License.
 
 import asyncio
 import logging
-import re
 from collections import defaultdict
 from time import time
 
 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.nodes import (
     CommunityNode,
     EntityNode,
@@ -36,6 +36,22 @@ logger = logging.getLogger(__name__)
 RELEVANT_SCHEMA_LIMIT = 3
 
 
+def fulltext_query(query: str, group_ids: list[str] | None = None):
+    group_ids_filter_list = (
+        [f'group_id:"{lucene_sanitize(g)}"' for g in group_ids] if group_ids is not None else []
+    )
+    group_ids_filter = ''
+    for f in group_ids_filter_list:
+        group_ids_filter += f if not group_ids_filter else f'OR {f}'
+
+    group_ids_filter += ' AND ' if group_ids_filter else ''
+
+    fuzzy_query = lucene_sanitize(query) + '~'
+    full_query = group_ids_filter + fuzzy_query
+
+    return full_query
+
+
 async def get_mentioned_nodes(
     driver: AsyncDriver, episodes: list[EpisodicNode]
 ) -> list[EntityNode]:
@@ -91,11 +107,15 @@ async def edge_fulltext_search(
     limit=RELEVANT_SCHEMA_LIMIT,
 ) -> list[EntityEdge]:
     # fulltext search over facts
+    fuzzy_query = fulltext_query(query, group_ids)
+
     cypher_query = Query("""
-              CALL db.index.fulltext.queryRelationships("name_and_fact", $query) 
+              CALL db.index.fulltext.queryRelationships("edge_name_and_fact", $query) 
               YIELD relationship AS rel, score
-              MATCH (n:Entity {uuid: $source_uuid})-[r {uuid: rel.uuid}]-(m:Entity {uuid: $target_uuid})
-              WHERE $group_ids IS NULL OR n.group_id IN $group_ids
+              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,
@@ -112,72 +132,6 @@ async def edge_fulltext_search(
                 ORDER BY score DESC LIMIT $limit
                 """)
 
-    if source_node_uuid is None and target_node_uuid is None:
-        cypher_query = Query("""
-                  CALL db.index.fulltext.queryRelationships("name_and_fact", $query) 
-                  YIELD relationship AS rel, score
-                  MATCH (n:Entity)-[r {uuid: rel.uuid}]-(m:Entity)
-                  WHERE $group_ids IS NULL OR r.group_id IN $group_ids
-                  RETURN 
-                        r.uuid AS uuid,
-                        r.group_id AS group_id,
-                        n.uuid AS source_node_uuid,
-                        m.uuid AS target_node_uuid,
-                        r.created_at AS created_at,
-                        r.name AS name,
-                        r.fact AS fact,
-                        r.fact_embedding AS fact_embedding,
-                        r.episodes AS episodes,
-                        r.expired_at AS expired_at,
-                        r.valid_at AS valid_at,
-                        r.invalid_at AS invalid_at
-                    ORDER BY score DESC LIMIT $limit
-                    """)
-    elif source_node_uuid is None:
-        cypher_query = Query("""
-                  CALL db.index.fulltext.queryRelationships("name_and_fact", $query) 
-                  YIELD relationship AS rel, score
-                  MATCH (n:Entity)-[r {uuid: rel.uuid}]-(m:Entity {uuid: $target_uuid})              
-                  WHERE $group_ids IS NULL OR r.group_id IN $group_ids
-                  RETURN 
-                        r.uuid AS uuid,
-                        r.group_id AS group_id,
-                        n.uuid AS source_node_uuid,
-                        m.uuid AS target_node_uuid,
-                        r.created_at AS created_at,
-                        r.name AS name,
-                        r.fact AS fact,
-                        r.fact_embedding AS fact_embedding,
-                        r.episodes AS episodes,
-                        r.expired_at AS expired_at,
-                        r.valid_at AS valid_at,
-                        r.invalid_at AS invalid_at
-                    ORDER BY score DESC LIMIT $limit
-                    """)
-    elif target_node_uuid is None:
-        cypher_query = Query("""
-                  CALL db.index.fulltext.queryRelationships("name_and_fact", $query) 
-                  YIELD relationship AS rel, score
-                  MATCH (n:Entity {uuid: $source_uuid})-[r {uuid: rel.uuid}]-(m:Entity)              
-                  WHERE $group_ids IS NULL OR r.group_id IN $group_ids
-                  RETURN 
-                        r.uuid AS uuid,
-                        r.group_id AS group_id,
-                        n.uuid AS source_node_uuid,
-                        m.uuid AS target_node_uuid,
-                        r.created_at AS created_at,
-                        r.name AS name,
-                        r.fact AS fact,
-                        r.fact_embedding AS fact_embedding,
-                        r.episodes AS episodes,
-                        r.expired_at AS expired_at,
-                        r.valid_at AS valid_at,
-                        r.invalid_at AS invalid_at
-                    ORDER BY score DESC LIMIT $limit
-                    """)
-
-    fuzzy_query = re.sub(r'[^\w\s]', '', query) + '~'
-
     records, _, _ = await driver.execute_query(
         cypher_query,
         query=fuzzy_query,
@@ -202,11 +156,12 @@ async def edge_similarity_search(
 ) -> list[EntityEdge]:
     # vector similarity search over embedded facts
     query = Query("""
-                CALL db.index.vector.queryRelationships("fact_embedding", $limit, $search_vector)
-                YIELD relationship AS rel, score
-                MATCH (n:Entity {uuid: $source_uuid})-[r {uuid: rel.uuid}]-(m:Entity {uuid: $target_uuid})
-                WHERE $group_ids IS NULL OR r.group_id IN $group_ids
+                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)
                 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,
@@ -220,72 +175,9 @@ async def edge_similarity_search(
                     r.valid_at AS valid_at,
                     r.invalid_at AS invalid_at
                 ORDER BY score DESC
+                LIMIT $limit
         """)
 
-    if source_node_uuid is None and target_node_uuid is None:
-        query = Query("""
-                    CALL db.index.vector.queryRelationships("fact_embedding", $limit, $search_vector)
-                    YIELD relationship AS rel, score
-                    MATCH (n:Entity)-[r {uuid: rel.uuid}]-(m:Entity)
-                    WHERE $group_ids IS NULL OR r.group_id IN $group_ids
-                    RETURN
-                        r.uuid AS uuid,
-                        r.group_id AS group_id,
-                        n.uuid AS source_node_uuid,
-                        m.uuid AS target_node_uuid,
-                        r.created_at AS created_at,
-                        r.name AS name,
-                        r.fact AS fact,
-                        r.fact_embedding AS fact_embedding,
-                        r.episodes AS episodes,
-                        r.expired_at AS expired_at,
-                        r.valid_at AS valid_at,
-                        r.invalid_at AS invalid_at
-                    ORDER BY score DESC
-            """)
-    elif source_node_uuid is None:
-        query = Query("""
-                    CALL db.index.vector.queryRelationships("fact_embedding", $limit, $search_vector)
-                    YIELD relationship AS rel, score
-                    MATCH (n:Entity)-[r {uuid: rel.uuid}]-(m:Entity {uuid: $target_uuid})
-                    WHERE $group_ids IS NULL OR r.group_id IN $group_ids
-                    RETURN
-                        r.uuid AS uuid,
-                        r.group_id AS group_id,
-                        n.uuid AS source_node_uuid,
-                        m.uuid AS target_node_uuid,
-                        r.created_at AS created_at,
-                        r.name AS name,
-                        r.fact AS fact,
-                        r.fact_embedding AS fact_embedding,
-                        r.episodes AS episodes,
-                        r.expired_at AS expired_at,
-                        r.valid_at AS valid_at,
-                        r.invalid_at AS invalid_at
-                    ORDER BY score DESC
-            """)
-    elif target_node_uuid is None:
-        query = Query("""
-                    CALL db.index.vector.queryRelationships("fact_embedding", $limit, $search_vector)
-                    YIELD relationship AS rel, score
-                    MATCH (n:Entity {uuid: $source_uuid})-[r {uuid: rel.uuid}]-(m:Entity)
-                    WHERE $group_ids IS NULL OR r.group_id IN $group_ids
-                    RETURN
-                        r.uuid AS uuid,
-                        r.group_id AS group_id,
-                        n.uuid AS source_node_uuid,
-                        m.uuid AS target_node_uuid,
-                        r.created_at AS created_at,
-                        r.name AS name,
-                        r.fact AS fact,
-                        r.fact_embedding AS fact_embedding,
-                        r.episodes AS episodes,
-                        r.expired_at AS expired_at,
-                        r.valid_at AS valid_at,
-                        r.invalid_at AS invalid_at
-                    ORDER BY score DESC
-            """)
-
     records, _, _ = await driver.execute_query(
         query,
         search_vector=search_vector,
@@ -307,10 +199,11 @@ async def node_fulltext_search(
     limit=RELEVANT_SCHEMA_LIMIT,
 ) -> list[EntityNode]:
     # BM25 search to get top nodes
-    fuzzy_query = re.sub(r'[^\w\s]', '', query) + '~'
+    fuzzy_query = fulltext_query(query, group_ids)
+
     records, _, _ = await driver.execute_query(
         """
-    CALL db.index.fulltext.queryNodes("name_and_summary", $query) 
+    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
@@ -341,11 +234,10 @@ async def node_similarity_search(
     # vector similarity search over entity names
     records, _, _ = await driver.execute_query(
         """
-                CALL db.index.vector.queryNodes("name_embedding", $limit, $search_vector)
-                YIELD node AS n, score
                 MATCH (n:Entity)
                 WHERE $group_ids IS NULL OR n.group_id IN $group_ids
                 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, 
@@ -353,6 +245,7 @@ async def node_similarity_search(
                     n.created_at AS created_at, 
                     n.summary AS summary
                 ORDER BY score DESC
+                LIMIT $limit
                 """,
         search_vector=search_vector,
         group_ids=group_ids,
@@ -370,7 +263,8 @@ async def community_fulltext_search(
     limit=RELEVANT_SCHEMA_LIMIT,
 ) -> list[CommunityNode]:
     # BM25 search to get top communities
-    fuzzy_query = re.sub(r'[^\w\s]', '', query) + '~'
+    fuzzy_query = fulltext_query(query, group_ids)
+
     records, _, _ = await driver.execute_query(
         """
     CALL db.index.fulltext.queryNodes("community_name", $query) 
@@ -405,11 +299,10 @@ async def community_similarity_search(
     # vector similarity search over entity names
     records, _, _ = await driver.execute_query(
         """
-                CALL db.index.vector.queryNodes("community_name_embedding", $limit, $search_vector)
-                YIELD node AS comm, score
                 MATCH (comm:Community)
-                WHERE $group_ids IS NULL OR comm.group_id IN $group_ids
+                WHERE ($group_ids IS NULL OR comm.group_id IN $group_ids)
                 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, 
@@ -417,6 +310,7 @@ async def community_similarity_search(
                     comm.created_at AS created_at, 
                     comm.summary AS summary
                 ORDER BY score DESC
+                LIMIT $limit
                 """,
         search_vector=search_vector,
         group_ids=group_ids,

graphiti_core/utils/maintenance/community_operations.py

@@ -7,6 +7,7 @@ from neo4j import AsyncDriver
 from pydantic import BaseModel
 
 from graphiti_core.edges import CommunityEdge
+from graphiti_core.embedder import EmbedderClient
 from graphiti_core.llm_client import LLMClient
 from graphiti_core.nodes import CommunityNode, EntityNode, get_community_node_from_record
 from graphiti_core.prompts import prompt_library
@@ -288,7 +289,7 @@ async def determine_entity_community(
 
 
 async def update_community(
-    driver: AsyncDriver, llm_client: LLMClient, embedder, entity: EntityNode
+    driver: AsyncDriver, llm_client: LLMClient, embedder: EmbedderClient, entity: EntityNode
 ):
     community, is_new = await determine_entity_community(driver, entity)
 

graphiti_core/utils/maintenance/graph_data_operations.py

@@ -28,7 +28,16 @@ EPISODE_WINDOW_LEN = 3
 logger = logging.getLogger(__name__)
 
 
-async def build_indices_and_constraints(driver: AsyncDriver):
+async def build_indices_and_constraints(driver: AsyncDriver, delete_existing: bool = False):
+    if delete_existing:
+        records, _, _ = await driver.execute_query("""
+        SHOW INDEXES YIELD name
+        """)
+        index_names = [record['name'] for record in records]
+        await asyncio.gather(
+            *[driver.execute_query("""DROP INDEX $name""", name=name) for name in index_names]
+        )
+
     range_indices: list[LiteralString] = [
         'CREATE INDEX entity_uuid IF NOT EXISTS FOR (n:Entity) ON (n.uuid)',
         'CREATE INDEX episode_uuid IF NOT EXISTS FOR (n:Episodic) ON (n.uuid)',
@@ -52,38 +61,15 @@ async def build_indices_and_constraints(driver: AsyncDriver):
     ]
 
     fulltext_indices: list[LiteralString] = [
-        'CREATE FULLTEXT INDEX name_and_summary IF NOT EXISTS FOR (n:Entity) ON EACH [n.name, n.summary]',
-        'CREATE FULLTEXT INDEX community_name IF NOT EXISTS FOR (n:Community) ON EACH [n.name]',
-        'CREATE FULLTEXT INDEX name_and_fact IF NOT EXISTS FOR ()-[e:RELATES_TO]-() ON EACH [e.name, e.fact]',
+        """CREATE FULLTEXT INDEX node_name_and_summary IF NOT EXISTS 
+        FOR (n:Entity) ON EACH [n.name, n.summary, n.group_id]""",
+        """CREATE FULLTEXT INDEX community_name IF NOT EXISTS 
+        FOR (n:Community) ON EACH [n.name, n.group_id]""",
+        """CREATE FULLTEXT INDEX edge_name_and_fact IF NOT EXISTS 
+        FOR ()-[e:RELATES_TO]-() ON EACH [e.name, e.fact, e.group_id]""",
     ]
 
-    vector_indices: list[LiteralString] = [
-        """
-        CREATE VECTOR INDEX fact_embedding IF NOT EXISTS
-        FOR ()-[r:RELATES_TO]-() ON (r.fact_embedding)
-        OPTIONS {indexConfig: {
-         `vector.dimensions`: 1024,
-         `vector.similarity_function`: 'cosine'
-        }}
-        """,
-        """
-        CREATE VECTOR INDEX name_embedding IF NOT EXISTS
-        FOR (n:Entity) ON (n.name_embedding)
-        OPTIONS {indexConfig: {
-         `vector.dimensions`: 1024,
-         `vector.similarity_function`: 'cosine'
-        }}
-        """,
-        """
-        CREATE VECTOR INDEX community_name_embedding IF NOT EXISTS
-        FOR (n:Community) ON (n.name_embedding)
-        OPTIONS {indexConfig: {
-         `vector.dimensions`: 1024,
-         `vector.similarity_function`: 'cosine'
-        }}
-        """,
-    ]
-    index_queries: list[LiteralString] = range_indices + fulltext_indices + vector_indices
+    index_queries: list[LiteralString] = range_indices + fulltext_indices
 
     await asyncio.gather(*[driver.execute_query(query) for query in index_queries])
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: graphiti-core
-Version: 0.3.6
+Version: 0.3.7
 Summary: A temporal graph building library
 License: Apache-2.0
 Author: Paul Paliychuk

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

@@ -1,43 +1,48 @@
 graphiti_core/__init__.py,sha256=e5SWFkRiaUwfprYIeIgVIh7JDedNiloZvd3roU-0aDY,55
-graphiti_core/edges.py,sha256=ePQfFHYXwYXqcTH_im9OjU74OH78f0fhCBo08aEXLoo,13471
+graphiti_core/edges.py,sha256=lLuRKjSHTk1GvTS06OUw2lSMiDAB4TQSXgnLq1fU3n8,13378
+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/errors.py,sha256=iJrkk5sTgc2z16ABS6TziPylEabdBJcpk0x9KyBUmxs,1527
-graphiti_core/graphiti.py,sha256=z6a4tCyDID_o6gloXDuUFmbL22bRiUE7A22JPYGVIyI,25947
-graphiti_core/helpers.py,sha256=qQqZJBkc_z5f3x5axPfCKK_QHLRybvWNFb57WXNENfQ,769
+graphiti_core/graphiti.py,sha256=5E2UbYlbl65D3MZyagEUPgoPrb_kVYDIqIw7KVlU_NM,26162
+graphiti_core/helpers.py,sha256=_wTSDcYmeXT3u0AwX15iSLuTRa_SR4jJdT10rxfl1_E,1484
 graphiti_core/llm_client/__init__.py,sha256=PA80TSMeX-sUXITXEAxMDEt3gtfZgcJrGJUcyds1mSo,207
-graphiti_core/llm_client/anthropic_client.py,sha256=16cWm_fQSUvJTSmgISBcNF8vytIhk-c5mmMK0Xd7SPE,2557
-graphiti_core/llm_client/client.py,sha256=g3vEBNV0E24HdKR3DmqjY8cqqr1CDlvrdh7SaiCUkDc,3470
-graphiti_core/llm_client/config.py,sha256=YIuR5XTINvxsEGDcpPXCqDWfWXGHTB4GB0k5DSRD7Rg,2360
+graphiti_core/llm_client/anthropic_client.py,sha256=4l2PbCjIoeRr7UJ2DUh2grYLTtE2vNaWlo72IIRQDeI,2405
+graphiti_core/llm_client/client.py,sha256=WAnX0e4EuCFHXdFHeq_O1HZsW1STSByvDCFUHMAHEFU,3394
+graphiti_core/llm_client/config.py,sha256=VwtvD0B7TNqE6Cl-rvH5v-bAfmjMLhEUuFmHSPt10EI,2339
 graphiti_core/llm_client/errors.py,sha256=-qlWwv1X-UjfsFIiNl-7yJIYvPwi7z8srVRfX4-s6uk,814
-graphiti_core/llm_client/groq_client.py,sha256=j467rL2tNaKplpTOP9pZNUCxG3rrHAEE26CBDk24jzw,2481
-graphiti_core/llm_client/openai_client.py,sha256=LlvhAI5nfrLUWehQ0TSPkeqzgV4wJMDiK56XUQxR21A,4002
-graphiti_core/llm_client/utils.py,sha256=0KT4XxTVw3c0__HLDj3F8kNR4K_qY0hT0TH-pQZ_IZw,1126
-graphiti_core/nodes.py,sha256=4RdkzvaiqEIqppkaYq53JLZ3tr6AskeKVOHOCJLR2BA,13847
+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/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/extract_nodes.py,sha256=VIr0Nh0mSiodI3iGOQFszh7DOni4mufOKJDuGkMysl8,6889
 graphiti_core/prompts/invalidate_edges.py,sha256=8SHt3iPTdmqk8A52LxgdMtI39w4USKqVDMOS2i6lRQ4,4342
-graphiti_core/prompts/lib.py,sha256=lIgVAxu4U4R9gnJVPkqxT4hcAXfErHECtM_Uceh55VA,3857
+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=QDgxWihEQuQ9H9BNGfWOEEDH0aGXUtwfpb7inhN88fk,8773
+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=LKFskMPqgRoxFpn5cdNYjAGTMy6z-FybNRBhNVtpJZM,23497
+graphiti_core/search/search_utils.py,sha256=WE-iVPI92AWR13aM3JQxtHaYoiPzDMtOOo8rEob8QEI,17844
 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=2jtA0ZwjwZyDiC1Es8d4p0KafT98w1fSkQOvi1IdT80,9809
+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/graph_data_operations.py,sha256=zk-Ir7msJIbdQj-8KTl0As9a8zYUG-e-dVdbVacxlf8,6515
+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/utils.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-graphiti_core-0.3.6.dist-info/LICENSE,sha256=KCUwCyDXuVEgmDWkozHyniRyWjnWUWjkuDHfU6o3JlA,11325
-graphiti_core-0.3.6.dist-info/METADATA,sha256=y5lM6qDP9MbjeNExduVvVaxyi7yP7vw7mxqsbOE7k5s,9395
-graphiti_core-0.3.6.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-graphiti_core-0.3.6.dist-info/RECORD,,
+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,,