graphiti-core 0.10.5__py3-none-any.whl → 0.11.0__py3-none-any.whl

graphiti_core/utils/maintenance/node_operations.py

@@ -20,80 +20,26 @@ from time import time
 from typing import Any
 
 import pydantic
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
 
+from graphiti_core.graphiti_types import GraphitiClients
 from graphiti_core.helpers import MAX_REFLEXION_ITERATIONS, semaphore_gather
 from graphiti_core.llm_client import LLMClient
-from graphiti_core.nodes import EntityNode, EpisodeType, EpisodicNode
+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.extract_nodes import EntityClassification, ExtractedNodes, MissedEntities
-from graphiti_core.prompts.summarize_nodes import Summary
+from graphiti_core.prompts.extract_nodes import (
+    ExtractedEntities,
+    ExtractedEntity,
+    MissedEntities,
+)
+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__)
 
 
-async def extract_message_nodes(
-    llm_client: LLMClient,
-    episode: EpisodicNode,
-    previous_episodes: list[EpisodicNode],
-    custom_prompt='',
-) -> list[str]:
-    # Prepare context for LLM
-    context = {
-        'episode_content': episode.content,
-        'episode_timestamp': episode.valid_at.isoformat(),
-        'previous_episodes': [ep.content for ep in previous_episodes],
-        'custom_prompt': custom_prompt,
-    }
-
-    llm_response = await llm_client.generate_response(
-        prompt_library.extract_nodes.extract_message(context), response_model=ExtractedNodes
-    )
-    extracted_node_names = llm_response.get('extracted_node_names', [])
-    return extracted_node_names
-
-
-async def extract_text_nodes(
-    llm_client: LLMClient,
-    episode: EpisodicNode,
-    previous_episodes: list[EpisodicNode],
-    custom_prompt='',
-) -> list[str]:
-    # Prepare context for LLM
-    context = {
-        'episode_content': episode.content,
-        'episode_timestamp': episode.valid_at.isoformat(),
-        'previous_episodes': [ep.content for ep in previous_episodes],
-        'custom_prompt': custom_prompt,
-    }
-
-    llm_response = await llm_client.generate_response(
-        prompt_library.extract_nodes.extract_text(context), ExtractedNodes
-    )
-    extracted_node_names = llm_response.get('extracted_node_names', [])
-    return extracted_node_names
-
-
-async def extract_json_nodes(
-    llm_client: LLMClient, episode: EpisodicNode, custom_prompt=''
-) -> list[str]:
-    # Prepare context for LLM
-    context = {
-        'episode_content': episode.content,
-        'episode_timestamp': episode.valid_at.isoformat(),
-        'source_description': episode.source_description,
-        'custom_prompt': custom_prompt,
-    }
-
-    llm_response = await llm_client.generate_response(
-        prompt_library.extract_nodes.extract_json(context), ExtractedNodes
-    )
-    extracted_node_names = llm_response.get('extracted_node_names', [])
-    return extracted_node_names
-
-
 async def extract_nodes_reflexion(
     llm_client: LLMClient,
     episode: EpisodicNode,
@@ -116,97 +62,108 @@ async def extract_nodes_reflexion(
 
 
 async def extract_nodes(
-    llm_client: LLMClient,
+    clients: GraphitiClients,
     episode: EpisodicNode,
     previous_episodes: list[EpisodicNode],
     entity_types: dict[str, BaseModel] | None = None,
 ) -> list[EntityNode]:
     start = time()
-    extracted_node_names: list[str] = []
+    llm_client = clients.llm_client
+    embedder = clients.embedder
+    llm_response = {}
     custom_prompt = ''
     entities_missed = True
     reflexion_iterations = 0
-    while entities_missed and reflexion_iterations < MAX_REFLEXION_ITERATIONS:
+
+    entity_types_context = [
+        {
+            'entity_type_id': 0,
+            'entity_type_name': 'Entity',
+            'entity_type_description': 'Default entity classification. Use this entity type if the entity is not one of the other listed types.',
+        }
+    ]
+
+    entity_types_context += (
+        [
+            {
+                'entity_type_id': i + 1,
+                'entity_type_name': type_name,
+                'entity_type_description': type_model.__doc__,
+            }
+            for i, (type_name, type_model) in enumerate(entity_types.items())
+        ]
+        if entity_types is not None
+        else []
+    )
+
+    context = {
+        'episode_content': episode.content,
+        'episode_timestamp': episode.valid_at.isoformat(),
+        'previous_episodes': [ep.content for ep in previous_episodes],
+        'custom_prompt': custom_prompt,
+        'entity_types': entity_types_context,
+    }
+
+    while entities_missed and reflexion_iterations <= MAX_REFLEXION_ITERATIONS:
         if episode.source == EpisodeType.message:
-            extracted_node_names = await extract_message_nodes(
-                llm_client, episode, previous_episodes, custom_prompt
+            llm_response = await llm_client.generate_response(
+                prompt_library.extract_nodes.extract_message(context),
+                response_model=ExtractedEntities,
             )
         elif episode.source == EpisodeType.text:
-            extracted_node_names = await extract_text_nodes(
-                llm_client, episode, previous_episodes, custom_prompt
+            llm_response = await llm_client.generate_response(
+                prompt_library.extract_nodes.extract_text(context), response_model=ExtractedEntities
             )
         elif episode.source == EpisodeType.json:
-            extracted_node_names = await extract_json_nodes(llm_client, episode, custom_prompt)
+            llm_response = await llm_client.generate_response(
+                prompt_library.extract_nodes.extract_json(context), response_model=ExtractedEntities
+            )
+
+        extracted_entities: list[ExtractedEntity] = [
+            ExtractedEntity(**entity_types_context)
+            for entity_types_context in llm_response.get('extracted_entities', [])
+        ]
 
         reflexion_iterations += 1
         if reflexion_iterations < MAX_REFLEXION_ITERATIONS:
             missing_entities = await extract_nodes_reflexion(
-                llm_client, episode, previous_episodes, extracted_node_names
+                llm_client,
+                episode,
+                previous_episodes,
+                [entity.name for entity in extracted_entities],
             )
 
             entities_missed = len(missing_entities) != 0
 
-            custom_prompt = 'The following entities were missed in a previous extraction: '
+            custom_prompt = 'Make sure that the following entities are extracted: '
             for entity in missing_entities:
                 custom_prompt += f'\n{entity},'
 
-    node_classification_context = {
-        'episode_content': episode.content,
-        'previous_episodes': [ep.content for ep in previous_episodes],
-        'extracted_entities': extracted_node_names,
-        'entity_types': {
-            type_name: values.model_json_schema().get('description')
-            for type_name, values in entity_types.items()
-        }
-        if entity_types is not None
-        else {},
-    }
-
-    node_classifications: dict[str, str | None] = {}
-
-    if entity_types is not None:
-        try:
-            llm_response = await llm_client.generate_response(
-                prompt_library.extract_nodes.classify_nodes(node_classification_context),
-                response_model=EntityClassification,
-            )
-            entity_classifications = llm_response.get('entity_classifications', [])
-            node_classifications.update(
-                {
-                    entity_classification.get('name'): entity_classification.get('entity_type')
-                    for entity_classification in entity_classifications
-                }
-            )
-        # catch classification errors and continue if we can't classify
-        except Exception as e:
-            logger.exception(e)
-
     end = time()
-    logger.debug(f'Extracted new nodes: {extracted_node_names} in {(end - start) * 1000} ms')
+    logger.debug(f'Extracted new nodes: {extracted_entities} in {(end - start) * 1000} ms')
     # Convert the extracted data into EntityNode objects
-    new_nodes = []
-    for name in extracted_node_names:
-        entity_type = node_classifications.get(name)
-        if entity_types is not None and entity_type not in entity_types:
-            entity_type = None
-
-        labels = (
-            ['Entity']
-            if entity_type is None or entity_type == 'None' or entity_type == 'null'
-            else ['Entity', entity_type]
+    extracted_nodes = []
+    for extracted_entity in extracted_entities:
+        entity_type_name = entity_types_context[extracted_entity.entity_type_id].get(
+            'entity_type_name'
         )
 
+        labels: list[str] = list({'Entity', str(entity_type_name)})
+
         new_node = EntityNode(
-            name=name,
+            name=extracted_entity.name,
             group_id=episode.group_id,
             labels=labels,
             summary='',
             created_at=utc_now(),
         )
-        new_nodes.append(new_node)
+        extracted_nodes.append(new_node)
         logger.debug(f'Created new node: {new_node.name} (UUID: {new_node.uuid})')
 
-    return new_nodes
+    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
 
 
 async def dedupe_extracted_nodes(
@@ -260,36 +217,45 @@ async def dedupe_extracted_nodes(
 
 
 async def resolve_extracted_nodes(
-    llm_client: LLMClient,
+    clients: GraphitiClients,
     extracted_nodes: list[EntityNode],
-    existing_nodes_lists: list[list[EntityNode]],
     episode: EpisodicNode | None = None,
     previous_episodes: list[EpisodicNode] | None = None,
     entity_types: dict[str, BaseModel] | None = None,
 ) -> tuple[list[EntityNode], dict[str, str]]:
-    uuid_map: dict[str, str] = {}
-    resolved_nodes: list[EntityNode] = []
-    results: list[tuple[EntityNode, dict[str, str]]] = list(
-        await semaphore_gather(
-            *[
-                resolve_extracted_node(
-                    llm_client,
-                    extracted_node,
-                    existing_nodes,
-                    episode,
-                    previous_episodes,
-                    entity_types,
-                )
-                for extracted_node, existing_nodes in zip(
-                    extracted_nodes, existing_nodes_lists, strict=False
+    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(
+        *[
+            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
+            )
+        ]
     )
 
-    for result in results:
-        uuid_map.update(result[1])
-        resolved_nodes.append(result[0])
+    uuid_map: dict[str, str] = {}
+    for extracted_node, resolved_node in zip(extracted_nodes, resolved_nodes, strict=True):
+        uuid_map[extracted_node.uuid] = resolved_node.uuid
+
+    logger.debug(f'Resolved nodes: {[(n.name, n.uuid) for n in resolved_nodes]}')
 
     return resolved_nodes, uuid_map
 
@@ -300,124 +266,151 @@ async def resolve_extracted_node(
     existing_nodes: list[EntityNode],
     episode: EpisodicNode | None = None,
     previous_episodes: list[EpisodicNode] | None = None,
-    entity_types: dict[str, BaseModel] | None = None,
-) -> tuple[EntityNode, dict[str, str]]:
+    entity_type: BaseModel | None = None,
+) -> EntityNode:
     start = time()
+    if len(existing_nodes) == 0:
+        return extracted_node
 
     # Prepare context for LLM
     existing_nodes_context = [
-        {**{'uuid': node.uuid, 'name': node.name, 'summary': node.summary}, **node.attributes}
-        for node in existing_nodes
+        {
+            **{
+                'id': i,
+                'name': node.name,
+                'entity_types': node.labels,
+                'summary': node.summary,
+            },
+            **node.attributes,
+        }
+        for i, node in enumerate(existing_nodes)
     ]
 
     extracted_node_context = {
-        'uuid': extracted_node.uuid,
         'name': extracted_node.name,
-        'summary': extracted_node.summary,
+        'entity_type': entity_type.__name__ if entity_type is not None else 'Entity',  # type: ignore
+        'entity_type_description': entity_type.__doc__
+        if entity_type is not None
+        else 'Default Entity Type',
     }
 
     context = {
         'existing_nodes': existing_nodes_context,
-        'extracted_nodes': extracted_node_context,
+        'extracted_node': extracted_node_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 [],
     }
 
-    summary_context: dict[str, Any] = {
-        'node_name': extracted_node.name,
-        'node_summary': extracted_node.summary,
-        '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.node(context), response_model=NodeDuplicate
+    )
 
-    attributes: list[dict[str, str]] = []
+    duplicate_id: int = llm_response.get('duplicate_node_id', -1)
 
-    entity_type_classes: tuple[BaseModel, ...] = tuple()
-    if entity_types is not None:  # type: ignore
-        entity_type_classes = entity_type_classes + tuple(
-            filter(
-                lambda x: x is not None,  # type: ignore
-                [entity_types.get(entity_type) for entity_type in extracted_node.labels],  # type: ignore
-            )
-        )
+    node = (
+        existing_nodes[duplicate_id] if 0 <= duplicate_id < len(existing_nodes) else extracted_node
+    )
 
-    for entity_type in entity_type_classes:
-        for field_name, field_info in entity_type.model_fields.items():
-            attributes.append(
-                {
-                    'attribute_name': field_name,
-                    'attribute_description': field_info.description or '',
-                }
-            )
+    end = time()
+    logger.debug(
+        f'Resolved node: {extracted_node.name} is {node.name}, in {(end - start) * 1000} ms'
+    )
 
-    summary_context['attributes'] = attributes
+    return node
 
-    entity_attributes_model = pydantic.create_model(  # type: ignore
-        'EntityAttributes',
-        __base__=entity_type_classes + (Summary,),  # type: ignore
-    )
 
-    llm_response, node_attributes_response = await semaphore_gather(
-        llm_client.generate_response(
-            prompt_library.dedupe_nodes.node(context), response_model=NodeDuplicate
-        ),
-        llm_client.generate_response(
-            prompt_library.summarize_nodes.summarize_context(summary_context),
-            response_model=entity_attributes_model,
-        ),
+async def extract_attributes_from_nodes(
+    clients: GraphitiClients,
+    nodes: list[EntityNode],
+    episode: EpisodicNode | None = None,
+    previous_episodes: list[EpisodicNode] | None = None,
+    entity_types: dict[str, BaseModel] | None = None,
+) -> list[EntityNode]:
+    llm_client = clients.llm_client
+    embedder = clients.embedder
+
+    updated_nodes: list[EntityNode] = await semaphore_gather(
+        *[
+            extract_attributes_from_node(
+                llm_client,
+                node,
+                episode,
+                previous_episodes,
+                entity_types.get(next((item for item in node.labels if item != 'Entity'), ''))
+                if entity_types is not None
+                else None,
+            )
+            for node in nodes
+        ]
     )
 
-    extracted_node.summary = node_attributes_response.get('summary', '')
-    node_attributes = {
-        key: value if (value != 'None' or key == 'summary') else None
-        for key, value in node_attributes_response.items()
-    }
+    await create_entity_node_embeddings(embedder, updated_nodes)
 
-    with suppress(KeyError):
-        del node_attributes['summary']
+    return updated_nodes
 
-    extracted_node.attributes.update(node_attributes)
 
-    is_duplicate: bool = llm_response.get('is_duplicate', False)
-    uuid: str | None = llm_response.get('uuid', None)
-    name = llm_response.get('name', '')
+async def extract_attributes_from_node(
+    llm_client: LLMClient,
+    node: EntityNode,
+    episode: EpisodicNode | None = None,
+    previous_episodes: list[EpisodicNode] | None = None,
+    entity_type: BaseModel | None = None,
+) -> EntityNode:
+    node_context: dict[str, Any] = {
+        'name': node.name,
+        'summary': node.summary,
+        'entity_types': node.labels,
+        'attributes': node.attributes,
+    }
 
-    node = extracted_node
-    uuid_map: dict[str, str] = {}
-    if is_duplicate:
-        for existing_node in existing_nodes:
-            if existing_node.uuid != uuid:
-                continue
-            summary_response = await llm_client.generate_response(
-                prompt_library.summarize_nodes.summarize_pair(
-                    {'node_summaries': [extracted_node.summary, existing_node.summary]}
-                ),
-                response_model=Summary,
+    attributes_definitions: dict[str, Any] = {
+        'summary': (
+            str,
+            Field(
+                description='Summary containing the important information about the entity. Under 200 words',
+            ),
+        ),
+        'name': (
+            str,
+            Field(description='Name of the ENTITY'),
+        ),
+    }
+
+    if entity_type is not None:
+        for field_name, field_info in entity_type.model_fields.items():
+            attributes_definitions[field_name] = (
+                field_info.annotation,
+                Field(description=field_info.description),
             )
-            node = existing_node
-            node.name = name
-            node.summary = summary_response.get('summary', '')
 
-            new_attributes = extracted_node.attributes
-            existing_attributes = existing_node.attributes
-            for attribute_name, attribute_value in existing_attributes.items():
-                if new_attributes.get(attribute_name) is None:
-                    new_attributes[attribute_name] = attribute_value
-            node.attributes = new_attributes
-            node.labels = list(set(existing_node.labels + extracted_node.labels))
+    entity_attributes_model = pydantic.create_model('EntityAttributes', **attributes_definitions)
 
-            uuid_map[extracted_node.uuid] = existing_node.uuid
+    summary_context: dict[str, Any] = {
+        'node': node_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 [],
+    }
 
-    end = time()
-    logger.debug(
-        f'Resolved node: {extracted_node.name} is {node.name}, in {(end - start) * 1000} ms'
+    llm_response = await llm_client.generate_response(
+        prompt_library.extract_nodes.extract_attributes(summary_context),
+        response_model=entity_attributes_model,
     )
 
-    return node, uuid_map
+    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)
+
+    return node
 
 
 async def dedupe_node_list(

graphiti_core/utils/maintenance/temporal_operations.py

@@ -72,12 +72,10 @@ async def get_edge_contradictions(
     llm_client: LLMClient, new_edge: EntityEdge, existing_edges: list[EntityEdge]
 ) -> list[EntityEdge]:
     start = time()
-    existing_edge_map = {edge.uuid: edge for edge in existing_edges}
 
-    new_edge_context = {'uuid': new_edge.uuid, 'name': new_edge.name, 'fact': new_edge.fact}
+    new_edge_context = {'fact': new_edge.fact}
     existing_edge_context = [
-        {'uuid': existing_edge.uuid, 'name': existing_edge.name, 'fact': existing_edge.fact}
-        for existing_edge in existing_edges
+        {'id': i, 'fact': existing_edge.fact} for i, existing_edge in enumerate(existing_edges)
     ]
 
     context = {'new_edge': new_edge_context, 'existing_edges': existing_edge_context}
@@ -86,14 +84,9 @@ async def get_edge_contradictions(
         prompt_library.invalidate_edges.v2(context), response_model=InvalidatedEdges
     )
 
-    contradicted_edge_data = llm_response.get('invalidated_edges', [])
+    contradicted_facts: list[int] = llm_response.get('contradicted_facts', [])
 
-    contradicted_edges: list[EntityEdge] = []
-    for edge_data in contradicted_edge_data:
-        if edge_data['uuid'] in existing_edge_map:
-            contradicted_edge = existing_edge_map[edge_data['uuid']]
-            contradicted_edge.fact = edge_data['fact']
-            contradicted_edges.append(contradicted_edge)
+    contradicted_edges: list[EntityEdge] = [existing_edges[i] for i in contradicted_facts]
 
     end = time()
     logger.debug(

{graphiti_core-0.10.5.dist-info → graphiti_core-0.11.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: graphiti-core
-Version: 0.10.5
+Version: 0.11.0
 Summary: A temporal graph building library
 License: Apache-2.0
 Author: Paul Paliychuk
@@ -42,11 +42,11 @@ Graphiti
 <h2 align="center"> Build Real-Time Knowledge Graphs for AI Agents</h2>
 <div align="center">
 
-
 [![Lint](https://github.com/getzep/Graphiti/actions/workflows/lint.yml/badge.svg?style=flat)](https://github.com/getzep/Graphiti/actions/workflows/lint.yml)
 [![Unit Tests](https://github.com/getzep/Graphiti/actions/workflows/unit_tests.yml/badge.svg)](https://github.com/getzep/Graphiti/actions/workflows/unit_tests.yml)
 [![MyPy Check](https://github.com/getzep/Graphiti/actions/workflows/typecheck.yml/badge.svg)](https://github.com/getzep/Graphiti/actions/workflows/typecheck.yml)
 
+![GitHub Repo stars](https://img.shields.io/github/stars/getzep/graphiti)
 [![Discord](https://dcbadge.vercel.app/api/server/W8Kw6bsgXQ?style=flat)](https://discord.com/invite/W8Kw6bsgXQ)
 [![arXiv](https://img.shields.io/badge/arXiv-2501.13956-b31b1b.svg?style=flat)](https://arxiv.org/abs/2501.13956)
 [![Release](https://img.shields.io/github/v/release/getzep/graphiti?style=flat&label=Release&color=limegreen)](https://github.com/getzep/graphiti/releases)
@@ -55,10 +55,16 @@ Graphiti
 <div align="center">
 
 <a href="https://trendshift.io/repositories/12986" target="_blank"><img src="https://trendshift.io/api/badge/repositories/12986" alt="getzep%2Fgraphiti | Trendshift" style="width: 250px; height: 55px;" width="250" height="55"/></a>
+
 </div>
+
 :star: _Help us reach more developers and grow the Graphiti community. Star this repo!_
+
 <br />
 
+> [!TIP]
+> Check out the new [MCP server for Graphiti](mcp_server/README.md)! Give Claude, Cursor, and other MCP clients powerful Knowledge Graph-based memory.
+
 Graphiti is a framework for building and querying temporally-aware knowledge graphs, specifically tailored for AI agents operating in dynamic environments. Unlike traditional retrieval-augmented generation (RAG) methods, Graphiti continuously integrates user interactions, structured and unstructured enterprise data, and external information into a coherent, queryable graph. The framework supports incremental data updates, efficient retrieval, and precise historical queries without requiring complete graph recomputation, making it suitable for developing interactive, context-aware AI applications.
 
 Use Graphiti to:
@@ -191,12 +197,6 @@ For a complete working example, see the [Quickstart Example](./examples/quicksta
 
 The example is fully documented with clear explanations of each functionality and includes a comprehensive README with setup instructions and next steps.
 
-## Graph Service
-
-The `server` directory contains an API service for interacting with the Graphiti API. It is built using FastAPI.
-
-Please see the [server README](./server/README.md) for more information.
-
 ## MCP Server
 
 The `mcp_server` directory contains a Model Context Protocol (MCP) server implementation for Graphiti. This server allows AI assistants to interact with Graphiti's knowledge graph capabilities through the MCP protocol.
@@ -213,6 +213,12 @@ The MCP server can be deployed using Docker with Neo4j, making it easy to integr
 
 For detailed setup instructions and usage examples, see the [MCP server README](./mcp_server/README.md).
 
+## REST Service
+
+The `server` directory contains an API service for interacting with the Graphiti API. It is built using FastAPI.
+
+Please see the [server README](./server/README.md) for more information.
+
 ## Optional Environment Variables
 
 In addition to the Neo4j and OpenAi-compatible credentials, Graphiti also has a few optional environment variables.