graphiti-core 0.11.4__py3-none-any.whl → 0.11.6__py3-none-any.whl

graphiti_core/search/search_utils.py

@@ -21,6 +21,7 @@ from typing import Any
 
 import numpy as np
 from neo4j import AsyncDriver, Query
+from numpy._typing import NDArray
 from typing_extensions import LiteralString
 
 from graphiti_core.edges import EntityEdge, get_entity_edge_from_record
@@ -101,7 +102,6 @@ async def get_mentioned_nodes(
             n.uuid As uuid, 
             n.group_id AS group_id,
             n.name AS name,
-            n.name_embedding AS name_embedding,
             n.created_at AS created_at, 
             n.summary AS summary,
             labels(n) AS labels,
@@ -128,7 +128,6 @@ async def get_communities_by_nodes(
         c.uuid As uuid, 
         c.group_id AS group_id,
         c.name AS name,
-        c.name_embedding AS name_embedding
         c.created_at AS created_at, 
         c.summary AS summary
     """,
@@ -172,7 +171,6 @@ async def edge_fulltext_search(
                      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,
@@ -242,7 +240,6 @@ async def edge_similarity_search(
                     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,
@@ -301,7 +298,6 @@ async def edge_bfs_search(
                     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,
@@ -341,10 +337,10 @@ async def node_fulltext_search(
 
     query = (
         """
-                                        CALL db.index.fulltext.queryNodes("node_name_and_summary", $query, {limit: $limit}) 
-                                        YIELD node AS n, score
-                                        WHERE n:Entity
-                                        """
+                                                                                CALL db.index.fulltext.queryNodes("node_name_and_summary", $query, {limit: $limit}) 
+                                                                                YIELD node AS n, score
+                                                                                WHERE n:Entity
+                                                                                """
         + filter_query
         + ENTITY_NODE_RETURN
         + """
@@ -510,7 +506,6 @@ async def community_fulltext_search(
             comm.uuid AS uuid,
             comm.group_id AS group_id, 
             comm.name AS name, 
-            comm.name_embedding AS name_embedding,
             comm.created_at AS created_at, 
             comm.summary AS summary
         ORDER BY score DESC
@@ -555,7 +550,6 @@ async def community_similarity_search(
                comm.uuid As uuid,
                comm.group_id AS group_id,
                comm.name AS name, 
-               comm.name_embedding AS name_embedding,
                comm.created_at AS created_at, 
                comm.summary AS summary
            ORDER BY score DESC
@@ -906,6 +900,7 @@ async def node_distance_reranker(
         node_uuids=filtered_uuids,
         center_uuid=center_node_uuid,
         database_=DEFAULT_DATABASE,
+        routing_='r',
     )
 
     for result in path_results:
@@ -946,6 +941,7 @@ async def episode_mentions_reranker(
         query,
         node_uuids=sorted_uuids,
         database_=DEFAULT_DATABASE,
+        routing_='r',
     )
 
     for result in results:
@@ -959,15 +955,116 @@ async def episode_mentions_reranker(
 
 def maximal_marginal_relevance(
     query_vector: list[float],
-    candidates: list[tuple[str, list[float]]],
+    candidates: dict[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))
+    min_score: float = -2.0,
+) -> list[str]:
+    start = time()
+    query_array = np.array(query_vector)
+    candidate_arrays: dict[str, NDArray] = {}
+    for uuid, embedding in candidates.items():
+        candidate_arrays[uuid] = normalize_l2(embedding)
+
+    uuids: list[str] = list(candidate_arrays.keys())
+
+    similarity_matrix = np.zeros((len(uuids), len(uuids)))
+
+    for i, uuid_1 in enumerate(uuids):
+        for j, uuid_2 in enumerate(uuids[:i]):
+            u = candidate_arrays[uuid_1]
+            v = candidate_arrays[uuid_2]
+            similarity = np.dot(u, v)
+
+            similarity_matrix[i, j] = similarity
+            similarity_matrix[j, i] = similarity
+
+    mmr_scores: dict[str, float] = {}
+    for i, uuid in enumerate(uuids):
+        max_sim = np.max(similarity_matrix[i, :])
+        mmr = mmr_lambda * np.dot(query_array, candidate_arrays[uuid]) + (mmr_lambda - 1) * max_sim
+        mmr_scores[uuid] = mmr
+
+    uuids.sort(reverse=True, key=lambda c: mmr_scores[c])
+
+    end = time()
+    logger.debug(f'Completed MMR reranking in {(end - start) * 1000} ms')
+
+    return [uuid for uuid in uuids if mmr_scores[uuid] >= min_score]
+
+
+async def get_embeddings_for_nodes(
+    driver: AsyncDriver, nodes: list[EntityNode]
+) -> dict[str, list[float]]:
+    query: LiteralString = """MATCH (n:Entity)
+                              WHERE n.uuid IN $node_uuids
+                              RETURN DISTINCT
+                                n.uuid AS uuid,
+                                n.name_embedding AS name_embedding
+                    """
+
+    results, _, _ = await driver.execute_query(
+        query, node_uuids=[node.uuid for node in nodes], database_=DEFAULT_DATABASE, routing_='r'
+    )
+
+    embeddings_dict: dict[str, list[float]] = {}
+    for result in results:
+        uuid: str = result.get('uuid')
+        embedding: list[float] = result.get('name_embedding')
+        if uuid is not None and embedding is not None:
+            embeddings_dict[uuid] = embedding
 
-    candidates_with_mmr.sort(reverse=True, key=lambda c: c[1])
+    return embeddings_dict
+
+
+async def get_embeddings_for_communities(
+    driver: AsyncDriver, communities: list[CommunityNode]
+) -> dict[str, list[float]]:
+    query: LiteralString = """MATCH (c:Community)
+                              WHERE c.uuid IN $community_uuids
+                              RETURN DISTINCT
+                                c.uuid AS uuid,
+                                c.name_embedding AS name_embedding
+                    """
+
+    results, _, _ = await driver.execute_query(
+        query,
+        community_uuids=[community.uuid for community in communities],
+        database_=DEFAULT_DATABASE,
+        routing_='r',
+    )
+
+    embeddings_dict: dict[str, list[float]] = {}
+    for result in results:
+        uuid: str = result.get('uuid')
+        embedding: list[float] = result.get('name_embedding')
+        if uuid is not None and embedding is not None:
+            embeddings_dict[uuid] = embedding
+
+    return embeddings_dict
+
+
+async def get_embeddings_for_edges(
+    driver: AsyncDriver, edges: list[EntityEdge]
+) -> dict[str, list[float]]:
+    query: LiteralString = """MATCH (n:Entity)-[e:RELATES_TO]-(m:Entity)
+                              WHERE e.uuid IN $edge_uuids
+                              RETURN DISTINCT
+                                e.uuid AS uuid,
+                                e.fact_embedding AS fact_embedding
+                    """
+
+    results, _, _ = await driver.execute_query(
+        query,
+        edge_uuids=[edge.uuid for edge in edges],
+        database_=DEFAULT_DATABASE,
+        routing_='r',
+    )
+
+    embeddings_dict: dict[str, list[float]] = {}
+    for result in results:
+        uuid: str = result.get('uuid')
+        embedding: list[float] = result.get('fact_embedding')
+        if uuid is not None and embedding is not None:
+            embeddings_dict[uuid] = embedding
 
-    return list(set([candidate[0] for candidate in candidates_with_mmr]))
+    return embeddings_dict

graphiti_core/utils/bulk_utils.py

@@ -26,6 +26,7 @@ from pydantic import BaseModel
 from typing_extensions import Any
 
 from graphiti_core.edges import Edge, EntityEdge, EpisodicEdge
+from graphiti_core.embedder import EmbedderClient
 from graphiti_core.graphiti_types import GraphitiClients
 from graphiti_core.helpers import DEFAULT_DATABASE, semaphore_gather
 from graphiti_core.llm_client import LLMClient
@@ -95,10 +96,16 @@ async def add_nodes_and_edges_bulk(
     episodic_edges: list[EpisodicEdge],
     entity_nodes: list[EntityNode],
     entity_edges: list[EntityEdge],
+    embedder: EmbedderClient,
 ):
     async with driver.session(database=DEFAULT_DATABASE) as session:
         await session.execute_write(
-            add_nodes_and_edges_bulk_tx, episodic_nodes, episodic_edges, entity_nodes, entity_edges
+            add_nodes_and_edges_bulk_tx,
+            episodic_nodes,
+            episodic_edges,
+            entity_nodes,
+            entity_edges,
+            embedder,
         )
 
 
@@ -108,12 +115,15 @@ async def add_nodes_and_edges_bulk_tx(
     episodic_edges: list[EpisodicEdge],
     entity_nodes: list[EntityNode],
     entity_edges: list[EntityEdge],
+    embedder: EmbedderClient,
 ):
     episodes = [dict(episode) for episode in episodic_nodes]
     for episode in episodes:
         episode['source'] = str(episode['source'].value)
     nodes: list[dict[str, Any]] = []
     for node in entity_nodes:
+        if node.name_embedding is None:
+            await node.generate_name_embedding(embedder)
         entity_data: dict[str, Any] = {
             'uuid': node.uuid,
             'name': node.name,
@@ -127,6 +137,10 @@ async def add_nodes_and_edges_bulk_tx(
         entity_data['labels'] = list(set(node.labels + ['Entity']))
         nodes.append(entity_data)
 
+    for edge in entity_edges:
+        if edge.fact_embedding is None:
+            await edge.generate_embedding(embedder)
+
     await tx.run(EPISODIC_NODE_SAVE_BULK, episodes=episodes)
     await tx.run(ENTITY_NODE_SAVE_BULK, nodes=nodes)
     await tx.run(

graphiti_core/utils/maintenance/community_operations.py

@@ -239,7 +239,6 @@ async def determine_entity_community(
     RETURN
         c.uuid As uuid, 
         c.name AS name,
-        c.name_embedding AS name_embedding,
         c.group_id AS group_id,
         c.created_at AS created_at, 
         c.summary AS summary
@@ -258,7 +257,6 @@ async def determine_entity_community(
     RETURN
         c.uuid As uuid, 
         c.name AS name,
-        c.name_embedding AS name_embedding,
         c.group_id AS group_id,
         c.created_at AS created_at, 
         c.summary AS summary

graphiti_core/utils/maintenance/edge_operations.py

@@ -35,9 +35,6 @@ from graphiti_core.prompts.extract_edges import ExtractedEdges, MissingFacts
 from graphiti_core.search.search_filters import SearchFilters
 from graphiti_core.search.search_utils import get_edge_invalidation_candidates, get_relevant_edges
 from graphiti_core.utils.datetime_utils import ensure_utc, utc_now
-from graphiti_core.utils.maintenance.temporal_operations import (
-    get_edge_contradictions,
-)
 
 logger = logging.getLogger(__name__)
 
@@ -91,7 +88,6 @@ async def extract_edges(
 
     extract_edges_max_tokens = 16384
     llm_client = clients.llm_client
-    embedder = clients.embedder
 
     node_uuids_by_name_map = {node.name: node.uuid for node in nodes}
 
@@ -184,8 +180,6 @@ async def extract_edges(
             f'Created new edge: {edge.name} from (UUID: {edge.source_node_uuid}) to (UUID: {edge.target_node_uuid})'
         )
 
-    await create_entity_edge_embeddings(embedder, edges)
-
     logger.debug(f'Extracted edges: {[(e.name, e.uuid) for e in edges]}')
 
     return edges
@@ -238,13 +232,17 @@ async def dedupe_extracted_edges(
 async def resolve_extracted_edges(
     clients: GraphitiClients,
     extracted_edges: list[EntityEdge],
+    episode: EpisodicNode,
 ) -> tuple[list[EntityEdge], list[EntityEdge]]:
     driver = clients.driver
     llm_client = clients.llm_client
+    embedder = clients.embedder
+
+    await create_entity_edge_embeddings(embedder, extracted_edges)
 
     search_results: tuple[list[list[EntityEdge]], list[list[EntityEdge]]] = await semaphore_gather(
         get_relevant_edges(driver, extracted_edges, SearchFilters()),
-        get_edge_invalidation_candidates(driver, extracted_edges, SearchFilters()),
+        get_edge_invalidation_candidates(driver, extracted_edges, SearchFilters(), 0.2),
     )
 
     related_edges_lists, edge_invalidation_candidates = search_results
@@ -258,10 +256,7 @@ async def resolve_extracted_edges(
         await semaphore_gather(
             *[
                 resolve_extracted_edge(
-                    llm_client,
-                    extracted_edge,
-                    related_edges,
-                    existing_edges,
+                    llm_client, extracted_edge, related_edges, existing_edges, episode
                 )
                 for extracted_edge, related_edges, existing_edges in zip(
                     extracted_edges, related_edges_lists, edge_invalidation_candidates, strict=True
@@ -281,6 +276,11 @@ async def resolve_extracted_edges(
 
     logger.debug(f'Resolved edges: {[(e.name, e.uuid) for e in resolved_edges]}')
 
+    await semaphore_gather(
+        create_entity_edge_embeddings(embedder, resolved_edges),
+        create_entity_edge_embeddings(embedder, invalidated_edges),
+    )
+
     return resolved_edges, invalidated_edges
 
 
@@ -322,10 +322,52 @@ async def resolve_extracted_edge(
     extracted_edge: EntityEdge,
     related_edges: list[EntityEdge],
     existing_edges: list[EntityEdge],
+    episode: EpisodicNode | None = None,
 ) -> tuple[EntityEdge, list[EntityEdge]]:
-    resolved_edge, invalidation_candidates = await semaphore_gather(
-        dedupe_extracted_edge(llm_client, extracted_edge, related_edges),
-        get_edge_contradictions(llm_client, extracted_edge, existing_edges),
+    if len(related_edges) == 0 and len(existing_edges) == 0:
+        return extracted_edge, []
+
+    start = time()
+
+    # Prepare context for LLM
+    related_edges_context = [
+        {'id': edge.uuid, 'fact': edge.fact} for i, edge in enumerate(related_edges)
+    ]
+
+    invalidation_edge_candidates_context = [
+        {'id': i, 'fact': existing_edge.fact} for i, existing_edge in enumerate(existing_edges)
+    ]
+
+    context = {
+        'existing_edges': related_edges_context,
+        'new_edge': extracted_edge.fact,
+        'edge_invalidation_candidates': invalidation_edge_candidates_context,
+    }
+
+    llm_response = await llm_client.generate_response(
+        prompt_library.dedupe_edges.resolve_edge(context),
+        response_model=EdgeDuplicate,
+        model_size=ModelSize.small,
+    )
+
+    duplicate_fact_id: int = llm_response.get('duplicate_fact_id', -1)
+
+    resolved_edge = (
+        related_edges[duplicate_fact_id]
+        if 0 <= duplicate_fact_id < len(related_edges)
+        else extracted_edge
+    )
+
+    if duplicate_fact_id >= 0 and episode is not None:
+        resolved_edge.episodes.append(episode.uuid)
+
+    contradicted_facts: list[int] = llm_response.get('contradicted_facts', [])
+
+    invalidation_candidates: list[EntityEdge] = [existing_edges[i] for i in contradicted_facts]
+
+    end = time()
+    logger.debug(
+        f'Resolved Edge: {extracted_edge.name} is {resolved_edge.name}, in {(end - start) * 1000} ms'
     )
 
     now = utc_now()
@@ -356,7 +398,10 @@ async def resolve_extracted_edge(
 
 
 async def dedupe_extracted_edge(
-    llm_client: LLMClient, extracted_edge: EntityEdge, related_edges: list[EntityEdge]
+    llm_client: LLMClient,
+    extracted_edge: EntityEdge,
+    related_edges: list[EntityEdge],
+    episode: EpisodicNode | None = None,
 ) -> EntityEdge:
     if len(related_edges) == 0:
         return extracted_edge
@@ -391,6 +436,9 @@ async def dedupe_extracted_edge(
         else extracted_edge
     )
 
+    if duplicate_fact_id >= 0 and episode is not None:
+        edge.episodes.append(episode.uuid)
+
     end = time()
     logger.debug(
         f'Resolved Edge: {extracted_edge.name} is {edge.name}, in {(end - start) * 1000} ms'

graphiti_core/utils/maintenance/node_operations.py

@@ -18,6 +18,7 @@ import logging
 from contextlib import suppress
 from time import time
 from typing import Any
+from uuid import uuid4
 
 import pydantic
 from pydantic import BaseModel, Field
@@ -28,14 +29,16 @@ from graphiti_core.llm_client import LLMClient
 from graphiti_core.llm_client.config import ModelSize
 from graphiti_core.nodes import EntityNode, EpisodeType, EpisodicNode, create_entity_node_embeddings
 from graphiti_core.prompts import prompt_library
-from graphiti_core.prompts.dedupe_nodes import NodeDuplicate
+from graphiti_core.prompts.dedupe_nodes import NodeDuplicate, NodeResolutions
 from graphiti_core.prompts.extract_nodes import (
     ExtractedEntities,
     ExtractedEntity,
     MissedEntities,
 )
+from graphiti_core.search.search import search
+from graphiti_core.search.search_config import SearchResults
+from graphiti_core.search.search_config_recipes import NODE_HYBRID_SEARCH_RRF
 from graphiti_core.search.search_filters import SearchFilters
-from graphiti_core.search.search_utils import get_relevant_nodes
 from graphiti_core.utils.datetime_utils import utc_now
 
 logger = logging.getLogger(__name__)
@@ -70,7 +73,6 @@ async def extract_nodes(
 ) -> list[EntityNode]:
     start = time()
     llm_client = clients.llm_client
-    embedder = clients.embedder
     llm_response = {}
     custom_prompt = ''
     entities_missed = True
@@ -163,8 +165,6 @@ async def extract_nodes(
         extracted_nodes.append(new_node)
         logger.debug(f'Created new node: {new_node.name} (UUID: {new_node.uuid})')
 
-    await create_entity_node_embeddings(embedder, extracted_nodes)
-
     logger.debug(f'Extracted nodes: {[(n.name, n.uuid) for n in extracted_nodes]}')
     return extracted_nodes
 
@@ -227,35 +227,81 @@ async def resolve_extracted_nodes(
     entity_types: dict[str, BaseModel] | None = None,
 ) -> tuple[list[EntityNode], dict[str, str]]:
     llm_client = clients.llm_client
-    driver = clients.driver
 
-    # Find relevant nodes already in the graph
-    existing_nodes_lists: list[list[EntityNode]] = await get_relevant_nodes(
-        driver, extracted_nodes, SearchFilters()
-    )
-
-    resolved_nodes: list[EntityNode] = await semaphore_gather(
+    search_results: list[SearchResults] = await semaphore_gather(
         *[
-            resolve_extracted_node(
-                llm_client,
-                extracted_node,
-                existing_nodes,
-                episode,
-                previous_episodes,
-                entity_types.get(
-                    next((item for item in extracted_node.labels if item != 'Entity'), '')
-                )
-                if entity_types is not None
-                else None,
-            )
-            for extracted_node, existing_nodes in zip(
-                extracted_nodes, existing_nodes_lists, strict=True
+            search(
+                clients=clients,
+                query=node.name,
+                group_ids=[node.group_id],
+                search_filter=SearchFilters(),
+                config=NODE_HYBRID_SEARCH_RRF,
             )
+            for node in extracted_nodes
         ]
     )
 
+    existing_nodes_lists: list[list[EntityNode]] = [result.nodes for result in search_results]
+
+    entity_types_dict: dict[str, BaseModel] = entity_types if entity_types is not None else {}
+
+    # Prepare context for LLM
+    extracted_nodes_context = [
+        {
+            'id': i,
+            'name': node.name,
+            'entity_type': node.labels,
+            'entity_type_description': entity_types_dict.get(
+                next((item for item in node.labels if item != 'Entity'), '')
+            ).__doc__
+            or 'Default Entity Type',
+            'duplication_candidates': [
+                {
+                    **{
+                        'idx': j,
+                        'name': candidate.name,
+                        'entity_types': candidate.labels,
+                    },
+                    **candidate.attributes,
+                }
+                for j, candidate in enumerate(existing_nodes_lists[i])
+            ],
+        }
+        for i, node in enumerate(extracted_nodes)
+    ]
+
+    context = {
+        'extracted_nodes': extracted_nodes_context,
+        'episode_content': episode.content if episode is not None else '',
+        'previous_episodes': [ep.content for ep in previous_episodes]
+        if previous_episodes is not None
+        else [],
+    }
+
+    llm_response = await llm_client.generate_response(
+        prompt_library.dedupe_nodes.nodes(context),
+        response_model=NodeResolutions,
+    )
+
+    node_resolutions: list = llm_response.get('entity_resolutions', [])
+
+    resolved_nodes: list[EntityNode] = []
     uuid_map: dict[str, str] = {}
-    for extracted_node, resolved_node in zip(extracted_nodes, resolved_nodes, strict=True):
+    for resolution in node_resolutions:
+        resolution_id = resolution.get('id', -1)
+        duplicate_idx = resolution.get('duplicate_idx', -1)
+
+        extracted_node = extracted_nodes[resolution_id]
+
+        resolved_node = (
+            existing_nodes_lists[resolution_id][duplicate_idx]
+            if 0 <= duplicate_idx < len(existing_nodes_lists[resolution_id])
+            else extracted_node
+        )
+
+        resolved_node.name = resolution.get('name')
+
+        resolved_nodes.append(resolved_node)
         uuid_map[extracted_node.uuid] = resolved_node.uuid
 
     logger.debug(f'Resolved nodes: {[(n.name, n.uuid) for n in resolved_nodes]}')
@@ -375,7 +421,7 @@ async def extract_attributes_from_node(
         'summary': (
             str,
             Field(
-                description='Summary containing the important information about the entity. Under 500 words',
+                description='Summary containing the important information about the entity. Under 250 words',
             ),
         )
     }
@@ -387,7 +433,8 @@ async def extract_attributes_from_node(
                 Field(description=field_info.description),
             )
 
-    entity_attributes_model = pydantic.create_model('EntityAttributes', **attributes_definitions)
+    unique_model_name = f'EntityAttributes_{uuid4().hex}'
+    entity_attributes_model = pydantic.create_model(unique_model_name, **attributes_definitions)
 
     summary_context: dict[str, Any] = {
         'node': node_context,
@@ -400,15 +447,14 @@ async def extract_attributes_from_node(
     llm_response = await llm_client.generate_response(
         prompt_library.extract_nodes.extract_attributes(summary_context),
         response_model=entity_attributes_model,
+        model_size=ModelSize.small,
     )
 
     node.summary = llm_response.get('summary', node.summary)
-    node.name = llm_response.get('name', node.name)
     node_attributes = {key: value for key, value in llm_response.items()}
 
     with suppress(KeyError):
         del node_attributes['summary']
-        del node_attributes['name']
 
     node.attributes.update(node_attributes)
 
@@ -427,10 +473,7 @@ async def dedupe_node_list(
         node_map[node.uuid] = node
 
     # Prepare context for LLM
-    nodes_context = [
-        {'uuid': node.uuid, 'name': node.name, 'summary': node.summary}.update(node.attributes)
-        for node in nodes
-    ]
+    nodes_context = [{'uuid': node.uuid, 'name': node.name, **node.attributes} for node in nodes]
 
     context = {
         'nodes': nodes_context,

{graphiti_core-0.11.4.dist-info → graphiti_core-0.11.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: graphiti-core
-Version: 0.11.4
+Version: 0.11.6
 Summary: A temporal graph building library
 License: Apache-2.0
 Author: Paul Paliychuk
@@ -18,7 +18,6 @@ Provides-Extra: groq
 Requires-Dist: anthropic (>=0.49.0) ; extra == "anthropic"
 Requires-Dist: diskcache (>=5.6.3)
 Requires-Dist: google-genai (>=1.8.0) ; extra == "google-genai"
-Requires-Dist: graph-service (>=1.0.0.7,<2.0.0.0)
 Requires-Dist: groq (>=0.2.0) ; extra == "groq"
 Requires-Dist: neo4j (>=5.23.0)
 Requires-Dist: numpy (>=1.0.0)