graphrag-cache 3.0.0__tar.gz

graphrag_cache-3.0.0/.gitignore

@@ -0,0 +1,65 @@
+# Python Artifacts
+python/*/lib/
+dist/
+build/
+*.egg-info/
+
+# Test Output
+.coverage
+coverage/
+licenses.txt
+examples_notebooks/*/data
+tests/fixtures/cache
+tests/fixtures/*/cache
+tests/fixtures/*/output
+output/lancedb
+
+
+# Random
+.DS_Store
+*.log*
+.venv
+venv/
+.conda
+.tmp
+packages/graphrag-llm/notebooks/metrics
+packages/graphrag-llm/notebooks/cache
+
+.env
+build.zip
+
+.turbo
+
+__pycache__
+
+.pipeline
+
+# Azurite
+temp_azurite/
+__azurite*.json
+__blobstorage*.json
+__blobstorage__/
+
+# Getting started example
+ragtest/
+.ragtest/
+.pipelines
+.pipeline
+
+
+# mkdocs
+site/
+
+# Docs migration
+docsite/
+.yarn/
+.pnp*
+
+# PyCharm
+.idea/
+
+# Jupyter notebook
+.ipynb_checkpoints/
+
+# Root build assets
+packages/*/LICENSE

graphrag_cache-3.0.0/LICENSE

@@ -0,0 +1,21 @@
+    MIT License
+
+    Copyright (c) Microsoft Corporation.
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to deal
+    in the Software without restriction, including without limitation the rights
+    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in all
+    copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+    SOFTWARE

graphrag_cache-3.0.0/PKG-INFO

@@ -0,0 +1,127 @@
+Metadata-Version: 2.4
+Name: graphrag-cache
+Version: 3.0.0
+Summary: GraphRAG cache package.
+Project-URL: Source, https://github.com/microsoft/graphrag
+Author: Mónica Carvajal
+Author-email: Alonso Guevara Fernández <alonsog@microsoft.com>, Andrés Morales Esquivel <andresmor@microsoft.com>, Chris Trevino <chtrevin@microsoft.com>, David Tittsworth <datittsw@microsoft.com>, Dayenne de Souza <ddesouza@microsoft.com>, Derek Worthen <deworthe@microsoft.com>, Gaudy Blanco Meneses <gaudyb@microsoft.com>, Ha Trinh <trinhha@microsoft.com>, Jonathan Larson <jolarso@microsoft.com>, Josh Bradley <joshbradley@microsoft.com>, Kate Lytvynets <kalytv@microsoft.com>, Kenny Zhang <zhangken@microsoft.com>, Nathan Evans <naevans@microsoft.com>, Rodrigo Racanicci <rracanicci@microsoft.com>, Sarah Smith <smithsarah@microsoft.com>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: <3.14,>=3.11
+Requires-Dist: graphrag-common==3.0.0
+Requires-Dist: graphrag-storage==3.0.0
+Description-Content-Type: text/markdown
+
+# GraphRAG Cache
+
+This package contains a collection of utilities to handle GraphRAG caching implementation.
+
+### Basic
+
+This example shows how to create a JSON cache with file storage using the GraphRAG cache package's configuration system. 
+
+```python
+import asyncio
+from graphrag_storage import StorageConfig, create_storage, StorageType
+from graphrag_cache import CacheConfig, create_cache, CacheType, create_cache_key
+
+async def run():
+    cache = create_cache()
+
+    # The above is equivalent to the following:
+    cache = create_cache(
+        CacheConfig(
+            type=CacheType.Json,
+            storage=StorageConfig(
+                type=StorageType.File,
+                base_dir="cache"
+            )
+        ),
+    )
+
+    await cache.set("my_key", {"some": "object to cache"})
+    print(await cache.get("my_key"))
+
+    # create cache key from data dict.
+    cache_key = create_cache_key({
+        "some_arg": "some_value",
+        "something_else": 5
+    })
+    await cache.set(cache_key, {"some": "object to cache"})
+    print(await cache.get(cache_key))
+
+if __name__ == "__main__":
+    asyncio.run(run())
+```
+
+### Custom Cache
+
+This demonstrates how to create a custom cache implementation by extending the base Cache class and registering it with the GraphRAG cache system. Once registered, the custom cache can be instantiated through the factory pattern using either CacheConfig or directly via cache_factory, allowing for extensible caching solutions tailored to specific needs.
+
+```python
+import asyncio
+from typing import Any
+from graphrag_storage import Storage
+from graphrag_cache import Cache, CacheConfig, create_cache, register_cache
+
+class MyCache(Cache):
+    def __init__(self, some_setting: str, optional_setting: str = "default setting", **kwargs: Any):
+        # Validate settings and initialize
+        # View the JsonCache implementation to see how to create a cache that relies on a Storage provider.
+        ...
+
+    #Implement rest of interface
+    ...
+
+register_cache("MyCache", MyCache)
+
+async def run():
+    cache = create_cache(
+        CacheConfig(
+            type="MyCache",
+            some_setting="My Setting"
+        )
+    )
+
+    # Or use the factory directly to instantiate with a dict instead of using
+    # CacheConfig + create_factory
+    # from graphrag_cache.cache_factory import cache_factory
+    # cache = cache_factory.create(strategy="MyCache", init_args={"some_setting": "My Setting"})
+
+    await cache.set("my_key", {"some": "object to cache"})
+    print(await cache.get("my_key"))
+
+if __name__ == "__main__":
+    asyncio.run(run())
+```
+
+#### Details
+
+By default, the `create_cache` comes with the following cache providers registered that correspond to the entries in the `CacheType` enum. 
+
+- `JsonCache`
+- `MemoryCache`
+- `NoopCache`
+
+The preregistration happens dynamically, e.g., `JsonCache` is only imported and registered if you request a `JsonCache` with `create_cache(CacheType.Json, ...)`. There is no need to manually import and register builtin cache providers when using `create_cache`.
+
+If you want a clean factory with no preregistered cache providers then directly import `cache_factory` and bypass using `create_cache`. The downside is that `cache_factory.create` uses a dict for init args instead of the strongly typed `CacheConfig` used with `create_cache`.
+
+```python
+from graphrag_cache.cache_factory import cache_factory
+from graphrag_cache.json_cache import JsonCache
+
+# cache_factory has no preregistered providers so you must register any
+# providers you plan on using.
+# May also register a custom implementation, see above for example.
+cache_factory.register("my_cache_impl", JsonCache)
+
+cache = cache_factory.create(strategy="my_cache_impl", init_args={"some_setting": "..."})
+
+...
+
+```

graphrag_cache-3.0.0/README.md

@@ -0,0 +1,109 @@
+# GraphRAG Cache
+
+This package contains a collection of utilities to handle GraphRAG caching implementation.
+
+### Basic
+
+This example shows how to create a JSON cache with file storage using the GraphRAG cache package's configuration system. 
+
+```python
+import asyncio
+from graphrag_storage import StorageConfig, create_storage, StorageType
+from graphrag_cache import CacheConfig, create_cache, CacheType, create_cache_key
+
+async def run():
+    cache = create_cache()
+
+    # The above is equivalent to the following:
+    cache = create_cache(
+        CacheConfig(
+            type=CacheType.Json,
+            storage=StorageConfig(
+                type=StorageType.File,
+                base_dir="cache"
+            )
+        ),
+    )
+
+    await cache.set("my_key", {"some": "object to cache"})
+    print(await cache.get("my_key"))
+
+    # create cache key from data dict.
+    cache_key = create_cache_key({
+        "some_arg": "some_value",
+        "something_else": 5
+    })
+    await cache.set(cache_key, {"some": "object to cache"})
+    print(await cache.get(cache_key))
+
+if __name__ == "__main__":
+    asyncio.run(run())
+```
+
+### Custom Cache
+
+This demonstrates how to create a custom cache implementation by extending the base Cache class and registering it with the GraphRAG cache system. Once registered, the custom cache can be instantiated through the factory pattern using either CacheConfig or directly via cache_factory, allowing for extensible caching solutions tailored to specific needs.
+
+```python
+import asyncio
+from typing import Any
+from graphrag_storage import Storage
+from graphrag_cache import Cache, CacheConfig, create_cache, register_cache
+
+class MyCache(Cache):
+    def __init__(self, some_setting: str, optional_setting: str = "default setting", **kwargs: Any):
+        # Validate settings and initialize
+        # View the JsonCache implementation to see how to create a cache that relies on a Storage provider.
+        ...
+
+    #Implement rest of interface
+    ...
+
+register_cache("MyCache", MyCache)
+
+async def run():
+    cache = create_cache(
+        CacheConfig(
+            type="MyCache",
+            some_setting="My Setting"
+        )
+    )
+
+    # Or use the factory directly to instantiate with a dict instead of using
+    # CacheConfig + create_factory
+    # from graphrag_cache.cache_factory import cache_factory
+    # cache = cache_factory.create(strategy="MyCache", init_args={"some_setting": "My Setting"})
+
+    await cache.set("my_key", {"some": "object to cache"})
+    print(await cache.get("my_key"))
+
+if __name__ == "__main__":
+    asyncio.run(run())
+```
+
+#### Details
+
+By default, the `create_cache` comes with the following cache providers registered that correspond to the entries in the `CacheType` enum. 
+
+- `JsonCache`
+- `MemoryCache`
+- `NoopCache`
+
+The preregistration happens dynamically, e.g., `JsonCache` is only imported and registered if you request a `JsonCache` with `create_cache(CacheType.Json, ...)`. There is no need to manually import and register builtin cache providers when using `create_cache`.
+
+If you want a clean factory with no preregistered cache providers then directly import `cache_factory` and bypass using `create_cache`. The downside is that `cache_factory.create` uses a dict for init args instead of the strongly typed `CacheConfig` used with `create_cache`.
+
+```python
+from graphrag_cache.cache_factory import cache_factory
+from graphrag_cache.json_cache import JsonCache
+
+# cache_factory has no preregistered providers so you must register any
+# providers you plan on using.
+# May also register a custom implementation, see above for example.
+cache_factory.register("my_cache_impl", JsonCache)
+
+cache = cache_factory.create(strategy="my_cache_impl", init_args={"some_setting": "..."})
+
+...
+
+```

graphrag_cache-3.0.0/graphrag_cache/__init__.py

@@ -0,0 +1,20 @@
+# Copyright (c) 2024 Microsoft Corporation.
+# Licensed under the MIT License
+
+"""The GraphRAG Cache package."""
+
+from graphrag_cache.cache import Cache
+from graphrag_cache.cache_config import CacheConfig
+from graphrag_cache.cache_factory import create_cache, register_cache
+from graphrag_cache.cache_key import CacheKeyCreator, create_cache_key
+from graphrag_cache.cache_type import CacheType
+
+__all__ = [
+    "Cache",
+    "CacheConfig",
+    "CacheKeyCreator",
+    "CacheType",
+    "create_cache",
+    "create_cache_key",
+    "register_cache",
+]

graphrag_cache-3.0.0/graphrag_cache/cache.py

@@ -0,0 +1,74 @@
+# Copyright (c) 2024 Microsoft Corporation.
+# Licensed under the MIT License
+
+"""Abstract base class for cache."""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from graphrag_storage import Storage
+
+
+class Cache(ABC):
+    """Provide a cache interface for the pipeline."""
+
+    @abstractmethod
+    def __init__(self, *, storage: Storage | None, **kwargs: Any) -> None:
+        """Create a cache instance."""
+
+    @abstractmethod
+    async def get(self, key: str) -> Any:
+        """Get the value for the given key.
+
+        Args:
+            - key - The key to get the value for.
+            - as_bytes - Whether or not to return the value as bytes.
+
+        Returns
+        -------
+            - output - The value for the given key.
+        """
+
+    @abstractmethod
+    async def set(self, key: str, value: Any, debug_data: dict | None = None) -> None:
+        """Set the value for the given key.
+
+        Args:
+            - key - The key to set the value for.
+            - value - The value to set.
+        """
+
+    @abstractmethod
+    async def has(self, key: str) -> bool:
+        """Return True if the given key exists in the cache.
+
+        Args:
+            - key - The key to check for.
+
+        Returns
+        -------
+            - output - True if the key exists in the cache, False otherwise.
+        """
+
+    @abstractmethod
+    async def delete(self, key: str) -> None:
+        """Delete the given key from the cache.
+
+        Args:
+            - key - The key to delete.
+        """
+
+    @abstractmethod
+    async def clear(self) -> None:
+        """Clear the cache."""
+
+    @abstractmethod
+    def child(self, name: str) -> Cache:
+        """Create a child cache with the given name.
+
+        Args:
+            - name - The name to create the sub cache with.
+        """

graphrag_cache-3.0.0/graphrag_cache/cache_config.py

@@ -0,0 +1,26 @@
+# Copyright (c) 2024 Microsoft Corporation.
+# Licensed under the MIT License
+
+"""Cache configuration model."""
+
+from graphrag_storage import StorageConfig, StorageType
+from pydantic import BaseModel, ConfigDict, Field
+
+from graphrag_cache.cache_type import CacheType
+
+
+class CacheConfig(BaseModel):
+    """The configuration section for cache."""
+
+    model_config = ConfigDict(extra="allow")
+    """Allow extra fields to support custom cache implementations."""
+
+    type: str = Field(
+        description="The cache type to use. Builtin types include 'Json', 'Memory', and 'Noop'.",
+        default=CacheType.Json,
+    )
+
+    storage: StorageConfig | None = Field(
+        description="The storage configuration to use for file-based caches such as 'Json'.",
+        default_factory=lambda: StorageConfig(type=StorageType.File, base_dir="cache"),
+    )

graphrag_cache-3.0.0/graphrag_cache/cache_factory.py

@@ -0,0 +1,95 @@
+# Copyright (c) 2024 Microsoft Corporation.
+# Licensed under the MIT License
+
+
+"""Cache factory implementation."""
+
+from collections.abc import Callable
+from typing import TYPE_CHECKING
+
+from graphrag_common.factory import Factory
+from graphrag_storage import create_storage
+
+from graphrag_cache.cache_config import CacheConfig
+from graphrag_cache.cache_type import CacheType
+
+if TYPE_CHECKING:
+    from graphrag_common.factory import ServiceScope
+    from graphrag_storage import Storage
+
+    from graphrag_cache.cache import Cache
+
+
+class CacheFactory(Factory["Cache"]):
+    """A factory class for cache implementations."""
+
+
+cache_factory = CacheFactory()
+
+
+def register_cache(
+    cache_type: str,
+    cache_initializer: Callable[..., "Cache"],
+    scope: "ServiceScope" = "transient",
+) -> None:
+    """Register a custom cache implementation.
+
+    Args
+    ----
+        - cache_type: str
+            The cache id to register.
+        - cache_initializer: Callable[..., Cache]
+            The cache initializer to register.
+    """
+    cache_factory.register(cache_type, cache_initializer, scope)
+
+
+def create_cache(
+    config: CacheConfig | None = None, storage: "Storage | None" = None
+) -> "Cache":
+    """Create a cache implementation based on the given configuration.
+
+    Args
+    ----
+        - config: CacheConfig
+            The cache configuration to use.
+        - storage: Storage | None
+            The storage implementation to use for file-based caches such as 'Json'.
+
+    Returns
+    -------
+        Cache
+            The created cache implementation.
+    """
+    config = config or CacheConfig()
+    config_model = config.model_dump()
+    cache_strategy = config.type
+
+    if not storage and config.storage:
+        storage = create_storage(config.storage)
+
+    if cache_strategy not in cache_factory:
+        match cache_strategy:
+            case CacheType.Json:
+                from graphrag_cache.json_cache import JsonCache
+
+                register_cache(CacheType.Json, JsonCache)
+
+            case CacheType.Memory:
+                from graphrag_cache.memory_cache import MemoryCache
+
+                register_cache(CacheType.Memory, MemoryCache)
+
+            case CacheType.Noop:
+                from graphrag_cache.noop_cache import NoopCache
+
+                register_cache(CacheType.Noop, NoopCache)
+
+            case _:
+                msg = f"CacheConfig.type '{cache_strategy}' is not registered in the CacheFactory. Registered types: {', '.join(cache_factory.keys())}."
+                raise ValueError(msg)
+
+    if storage:
+        config_model["storage"] = storage
+
+    return cache_factory.create(strategy=cache_strategy, init_args=config_model)

graphrag_cache-3.0.0/graphrag_cache/cache_key.py

@@ -0,0 +1,36 @@
+# Copyright (c) 2024 Microsoft Corporation.
+# Licensed under the MIT License
+
+"""Create cache key."""
+
+from typing import Any, Protocol, runtime_checkable
+
+from graphrag_common.hasher import hash_data
+
+
+@runtime_checkable
+class CacheKeyCreator(Protocol):
+    """Create cache key function protocol.
+
+    Args
+    ----
+        input_args: dict[str, Any]
+            The input arguments for creating the cache key.
+
+    Returns
+    -------
+        str
+            The generated cache key.
+    """
+
+    def __call__(
+        self,
+        input_args: dict[str, Any],
+    ) -> str:
+        """Create cache key."""
+        ...
+
+
+def create_cache_key(input_args: dict[str, Any]) -> str:
+    """Create a cache key based on the input arguments."""
+    return hash_data(input_args)

graphrag_cache-3.0.0/graphrag_cache/cache_type.py

@@ -0,0 +1,15 @@
+# Copyright (c) 2024 Microsoft Corporation.
+# Licensed under the MIT License
+
+
+"""Builtin cache implementation types."""
+
+from enum import StrEnum
+
+
+class CacheType(StrEnum):
+    """Enum for cache types."""
+
+    Json = "json"
+    Memory = "memory"
+    Noop = "none"

graphrag_cache-3.0.0/graphrag_cache/json_cache.py

@@ -0,0 +1,72 @@
+# Copyright (c) 2024 Microsoft Corporation.
+# Licensed under the MIT License
+
+"""A module containing 'JsonCache' model."""
+
+import json
+from typing import Any
+
+from graphrag_storage import Storage, StorageConfig, create_storage
+
+from graphrag_cache.cache import Cache
+
+
+class JsonCache(Cache):
+    """File pipeline cache class definition."""
+
+    _storage: Storage
+
+    def __init__(
+        self,
+        storage: Storage | dict[str, Any] | None = None,
+        **kwargs: Any,
+    ) -> None:
+        """Init method definition."""
+        if storage is None:
+            msg = "JsonCache requires either a Storage instance to be provided or a StorageConfig to create one."
+            raise ValueError(msg)
+        if isinstance(storage, Storage):
+            self._storage = storage
+        else:
+            self._storage = create_storage(StorageConfig(**storage))
+
+    async def get(self, key: str) -> Any | None:
+        """Get method definition."""
+        if await self.has(key):
+            try:
+                data = await self._storage.get(key)
+                data = json.loads(data)
+            except UnicodeDecodeError:
+                await self._storage.delete(key)
+                return None
+            except json.decoder.JSONDecodeError:
+                await self._storage.delete(key)
+                return None
+            else:
+                return data.get("result")
+
+        return None
+
+    async def set(self, key: str, value: Any, debug_data: dict | None = None) -> None:
+        """Set method definition."""
+        if value is None:
+            return
+        data = {"result": value, **(debug_data or {})}
+        await self._storage.set(key, json.dumps(data, ensure_ascii=False))
+
+    async def has(self, key: str) -> bool:
+        """Has method definition."""
+        return await self._storage.has(key)
+
+    async def delete(self, key: str) -> None:
+        """Delete method definition."""
+        if await self.has(key):
+            await self._storage.delete(key)
+
+    async def clear(self) -> None:
+        """Clear method definition."""
+        await self._storage.clear()
+
+    def child(self, name: str) -> "Cache":
+        """Child method definition."""
+        return JsonCache(storage=self._storage.child(name))

graphrag_cache-3.0.0/graphrag_cache/memory_cache.py

@@ -0,0 +1,69 @@
+# Copyright (c) 2024 Microsoft Corporation.
+# Licensed under the MIT License
+
+"""MemoryCache implementation."""
+
+from typing import Any
+
+from graphrag_cache.cache import Cache
+
+
+class MemoryCache(Cache):
+    """In memory cache class definition."""
+
+    _cache: dict[str, Any]
+    _name: str
+
+    def __init__(self, **kwargs: Any) -> None:
+        """Init method definition."""
+        self._cache = {}
+
+    async def get(self, key: str) -> Any:
+        """Get the value for the given key.
+
+        Args:
+            - key - The key to get the value for.
+            - as_bytes - Whether or not to return the value as bytes.
+
+        Returns
+        -------
+            - output - The value for the given key.
+        """
+        return self._cache.get(key)
+
+    async def set(self, key: str, value: Any, debug_data: dict | None = None) -> None:
+        """Set the value for the given key.
+
+        Args:
+            - key - The key to set the value for.
+            - value - The value to set.
+        """
+        self._cache[key] = value
+
+    async def has(self, key: str) -> bool:
+        """Return True if the given key exists in the storage.
+
+        Args:
+            - key - The key to check for.
+
+        Returns
+        -------
+            - output - True if the key exists in the storage, False otherwise.
+        """
+        return key in self._cache
+
+    async def delete(self, key: str) -> None:
+        """Delete the given key from the storage.
+
+        Args:
+            - key - The key to delete.
+        """
+        del self._cache[key]
+
+    async def clear(self) -> None:
+        """Clear the storage."""
+        self._cache.clear()
+
+    def child(self, name: str) -> "Cache":
+        """Create a sub cache with the given name."""
+        return MemoryCache()

graphrag_cache-3.0.0/graphrag_cache/noop_cache.py

@@ -0,0 +1,68 @@
+# Copyright (c) 2024 Microsoft Corporation.
+# Licensed under the MIT License
+
+"""NoopCache implementation."""
+
+from typing import Any
+
+from graphrag_cache.cache import Cache
+
+
+class NoopCache(Cache):
+    """A no-op implementation of Cache, usually useful for testing."""
+
+    def __init__(self, **kwargs: Any) -> None:
+        """Init method definition."""
+
+    async def get(self, key: str) -> Any:
+        """Get the value for the given key.
+
+        Args:
+            - key - The key to get the value for.
+            - as_bytes - Whether or not to return the value as bytes.
+
+        Returns
+        -------
+            - output - The value for the given key.
+        """
+        return None
+
+    async def set(
+        self, key: str, value: str | bytes | None, debug_data: dict | None = None
+    ) -> None:
+        """Set the value for the given key.
+
+        Args:
+            - key - The key to set the value for.
+            - value - The value to set.
+        """
+
+    async def has(self, key: str) -> bool:
+        """Return True if the given key exists in the cache.
+
+        Args:
+            - key - The key to check for.
+
+        Returns
+        -------
+            - output - True if the key exists in the cache, False otherwise.
+        """
+        return False
+
+    async def delete(self, key: str) -> None:
+        """Delete the given key from the cache.
+
+        Args:
+            - key - The key to delete.
+        """
+
+    async def clear(self) -> None:
+        """Clear the cache."""
+
+    def child(self, name: str) -> "Cache":
+        """Create a child cache with the given name.
+
+        Args:
+            - name - The name to create the sub cache with.
+        """
+        return self

graphrag_cache-3.0.0/pyproject.toml

@@ -0,0 +1,43 @@
+[project]
+name = "graphrag-cache"
+version = "3.0.0"
+description = "GraphRAG cache package."
+authors = [
+    {name = "Alonso Guevara Fernández", email = "alonsog@microsoft.com"},
+    {name = "Andrés Morales Esquivel", email = "andresmor@microsoft.com"},
+    {name = "Chris Trevino", email = "chtrevin@microsoft.com"},
+    {name = "David Tittsworth", email = "datittsw@microsoft.com"},
+    {name = "Dayenne de Souza", email = "ddesouza@microsoft.com"},
+    {name = "Derek Worthen", email = "deworthe@microsoft.com"},
+    {name = "Gaudy Blanco Meneses", email = "gaudyb@microsoft.com"},
+    {name = "Ha Trinh", email = "trinhha@microsoft.com"},
+    {name = "Jonathan Larson", email = "jolarso@microsoft.com"},
+    {name = "Josh Bradley", email = "joshbradley@microsoft.com"},
+    {name = "Kate Lytvynets", email = "kalytv@microsoft.com"},
+    {name = "Kenny Zhang", email = "zhangken@microsoft.com"},
+    {name = "Mónica Carvajal"},
+    {name = "Nathan Evans", email = "naevans@microsoft.com"},
+    {name = "Rodrigo Racanicci", email = "rracanicci@microsoft.com"},
+    {name = "Sarah Smith", email = "smithsarah@microsoft.com"},
+]
+license = "MIT"
+readme = "README.md"
+license-files = ["LICENSE"]
+requires-python = ">=3.11,<3.14"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+]
+dependencies = [
+    "graphrag-common==3.0.0",
+    "graphrag-storage==3.0.0",
+]
+
+[project.urls]
+Source = "https://github.com/microsoft/graphrag"
+
+[build-system]
+requires = ["hatchling>=1.27.0,<2.0.0"]
+build-backend = "hatchling.build"