kiln-ai 0.22.0__tar.gz → 0.22.1__tar.gz

{kiln_ai-0.22.0 → kiln_ai-0.22.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kiln-ai
-Version: 0.22.0
+Version: 0.22.1
 Summary: Kiln AI
 Project-URL: Homepage, https://kiln.tech
 Project-URL: Repository, https://github.com/Kiln-AI/kiln
@@ -85,6 +85,10 @@ The library has a [comprehensive set of docs](https://kiln-ai.github.io/Kiln/kil
   - [Building and Running a Kiln Task from Code](#building-and-running-a-kiln-task-from-code)
   - [Tagging Task Runs Programmatically](#tagging-task-runs-programmatically)
   - [Adding Custom Model or AI Provider from Code](#adding-custom-model-or-ai-provider-from-code)
+- [Taking Kiln RAG to production](#taking-kiln-rag-to-production)
+  - [Load a LlamaIndex Vector Store](#load-a-llamaindex-vector-store)
+  - [Example: LanceDB Cloud](#example-lancedb-cloud)
+  - [Deploy RAG without LlamaIndex](#deploy-rag-without-llamaindex)t
 - [Full API Reference](#full-api-reference)
 
 ## Installation
@@ -352,6 +356,78 @@ custom_model_ids.append(new_model)
 Config.shared().custom_models = custom_model_ids
 ```
 
+## Taking Kiln RAG to production
+
+When you're ready to deploy your RAG system, you can export your processed documents to any vector store supported by LlamaIndex. This allows you to use your Kiln-configured chunking and embedding settings in production.
+
+### Load a LlamaIndex Vector Store
+
+Kiln provides a `VectorStoreLoader` that yields your processed document chunks as LlamaIndex `TextNode` objects. These nodes contain the same metadata, chunking and embedding data as your Kiln Search Tool configuration.
+
+```py
+from kiln_ai.datamodel import Project
+from kiln_ai.datamodel.rag import RagConfig
+from kiln_ai.adapters.vector_store_loaders import VectorStoreLoader
+
+# Load your project and RAG configuration
+project = Project.load_from_file("path/to/your/project.kiln")
+rag_config = RagConfig.from_id_and_parent_path("rag-config-id", project.path)
+
+# Create the loader
+loader = VectorStoreLoader(project=project, rag_config=rag_config)
+
+# Export chunks to any LlamaIndex vector store
+async for batch in loader.iter_llama_index_nodes(batch_size=10):
+    # Insert into your chosen vector store
+    # Examples: LanceDB, Pinecone, Chroma, Qdrant, etc.
+    pass
+```
+
+**Supported Vector Stores:** LlamaIndex supports 20+ vector stores including LanceDB, Pinecone, Weaviate, Chroma, Qdrant, and more. See the [full list](https://developers.llamaindex.ai/python/framework/module_guides/storing/vector_stores/).
+
+### Example: LanceDB Cloud
+
+Internally Kiln uses LanceDB. By using LanceDB cloud you'll get the same indexing behaviour as in app.
+
+Here's a complete example using LanceDB Cloud:
+
+```py
+from kiln_ai.datamodel import Project
+from kiln_ai.datamodel.rag import RagConfig
+from kiln_ai.datamodel.vector_store import VectorStoreConfig
+from kiln_ai.adapters.vector_store_loaders import VectorStoreLoader
+from kiln_ai.adapters.vector_store.lancedb_adapter import lancedb_construct_from_config
+
+# Load configurations
+project = Project.load_from_file("path/to/your/project.kiln")
+rag_config = RagConfig.from_id_and_parent_path("rag-config-id", project.path)
+vector_store_config = VectorStoreConfig.from_id_and_parent_path(
+    rag_config.vector_store_config_id, project.path,
+)
+
+# Create LanceDB vector store
+lancedb_store = lancedb_construct_from_config(
+    vector_store_config=vector_store_config,
+    uri="db://my-project",
+    api_key="sk_...",
+    region="us-east-1",
+    table_name="my-documents",  # Created automatically
+)
+
+# Export and insert your documents
+loader = VectorStoreLoader(project=project, rag_config=rag_config)
+async for batch in loader.iter_llama_index_nodes(batch_size=100):
+    await lancedb_store.async_add(batch)
+
+print("Documents successfully exported to LanceDB!")
+```
+
+After export, query your data using [LlamaIndex](https://developers.llamaindex.ai/python/framework-api-reference/storage/vector_store/lancedb/) or the [LanceDB client](https://lancedb.github.io/lancedb/).
+
+### Deploy RAG without LlamaIndex
+
+While Kiln is designed for deploying to LlamaIndex, you don't need to use it. The `iter_llama_index_nodes` returns a `TextNode` object which includes all the data you need to build a RAG index in any stack: embedding, text, document name, chunk ID, etc.
+
 ## Full API Reference
 
 The library can do a lot more than the examples we've shown here.

{kiln_ai-0.22.0 → kiln_ai-0.22.1}/README.md

@@ -43,6 +43,10 @@ The library has a [comprehensive set of docs](https://kiln-ai.github.io/Kiln/kil
   - [Building and Running a Kiln Task from Code](#building-and-running-a-kiln-task-from-code)
   - [Tagging Task Runs Programmatically](#tagging-task-runs-programmatically)
   - [Adding Custom Model or AI Provider from Code](#adding-custom-model-or-ai-provider-from-code)
+- [Taking Kiln RAG to production](#taking-kiln-rag-to-production)
+  - [Load a LlamaIndex Vector Store](#load-a-llamaindex-vector-store)
+  - [Example: LanceDB Cloud](#example-lancedb-cloud)
+  - [Deploy RAG without LlamaIndex](#deploy-rag-without-llamaindex)t
 - [Full API Reference](#full-api-reference)
 
 ## Installation
@@ -310,6 +314,78 @@ custom_model_ids.append(new_model)
 Config.shared().custom_models = custom_model_ids
 ```
 
+## Taking Kiln RAG to production
+
+When you're ready to deploy your RAG system, you can export your processed documents to any vector store supported by LlamaIndex. This allows you to use your Kiln-configured chunking and embedding settings in production.
+
+### Load a LlamaIndex Vector Store
+
+Kiln provides a `VectorStoreLoader` that yields your processed document chunks as LlamaIndex `TextNode` objects. These nodes contain the same metadata, chunking and embedding data as your Kiln Search Tool configuration.
+
+```py
+from kiln_ai.datamodel import Project
+from kiln_ai.datamodel.rag import RagConfig
+from kiln_ai.adapters.vector_store_loaders import VectorStoreLoader
+
+# Load your project and RAG configuration
+project = Project.load_from_file("path/to/your/project.kiln")
+rag_config = RagConfig.from_id_and_parent_path("rag-config-id", project.path)
+
+# Create the loader
+loader = VectorStoreLoader(project=project, rag_config=rag_config)
+
+# Export chunks to any LlamaIndex vector store
+async for batch in loader.iter_llama_index_nodes(batch_size=10):
+    # Insert into your chosen vector store
+    # Examples: LanceDB, Pinecone, Chroma, Qdrant, etc.
+    pass
+```
+
+**Supported Vector Stores:** LlamaIndex supports 20+ vector stores including LanceDB, Pinecone, Weaviate, Chroma, Qdrant, and more. See the [full list](https://developers.llamaindex.ai/python/framework/module_guides/storing/vector_stores/).
+
+### Example: LanceDB Cloud
+
+Internally Kiln uses LanceDB. By using LanceDB cloud you'll get the same indexing behaviour as in app.
+
+Here's a complete example using LanceDB Cloud:
+
+```py
+from kiln_ai.datamodel import Project
+from kiln_ai.datamodel.rag import RagConfig
+from kiln_ai.datamodel.vector_store import VectorStoreConfig
+from kiln_ai.adapters.vector_store_loaders import VectorStoreLoader
+from kiln_ai.adapters.vector_store.lancedb_adapter import lancedb_construct_from_config
+
+# Load configurations
+project = Project.load_from_file("path/to/your/project.kiln")
+rag_config = RagConfig.from_id_and_parent_path("rag-config-id", project.path)
+vector_store_config = VectorStoreConfig.from_id_and_parent_path(
+    rag_config.vector_store_config_id, project.path,
+)
+
+# Create LanceDB vector store
+lancedb_store = lancedb_construct_from_config(
+    vector_store_config=vector_store_config,
+    uri="db://my-project",
+    api_key="sk_...",
+    region="us-east-1",
+    table_name="my-documents",  # Created automatically
+)
+
+# Export and insert your documents
+loader = VectorStoreLoader(project=project, rag_config=rag_config)
+async for batch in loader.iter_llama_index_nodes(batch_size=100):
+    await lancedb_store.async_add(batch)
+
+print("Documents successfully exported to LanceDB!")
+```
+
+After export, query your data using [LlamaIndex](https://developers.llamaindex.ai/python/framework-api-reference/storage/vector_store/lancedb/) or the [LanceDB client](https://lancedb.github.io/lancedb/).
+
+### Deploy RAG without LlamaIndex
+
+While Kiln is designed for deploying to LlamaIndex, you don't need to use it. The `iter_llama_index_nodes` returns a `TextNode` object which includes all the data you need to build a RAG index in any stack: embedding, text, document name, chunk ID, etc.
+
 ## Full API Reference
 
 The library can do a lot more than the examples we've shown here.

{kiln_ai-0.22.0 → kiln_ai-0.22.1}/kiln_ai/adapters/model_adapters/litellm_adapter.py

@@ -31,7 +31,11 @@ from kiln_ai.adapters.model_adapters.base_adapter import (
 )
 from kiln_ai.adapters.model_adapters.litellm_config import LiteLlmConfig
 from kiln_ai.datamodel.json_schema import validate_schema_with_value_error
-from kiln_ai.tools.base_tool import KilnToolInterface, ToolCallContext
+from kiln_ai.tools.base_tool import (
+    KilnToolInterface,
+    ToolCallContext,
+    ToolCallDefinition,
+)
 from kiln_ai.tools.kiln_task_tool import KilnTaskToolResult
 from kiln_ai.utils.exhaustive_error import raise_exhaustive_enum_error
 from kiln_ai.utils.litellm import get_litellm_provider_info
@@ -560,7 +564,7 @@ class LiteLlmAdapter(BaseAdapter):
             self._cached_available_tools = await self.available_tools()
         return self._cached_available_tools
 
-    async def litellm_tools(self) -> list[Dict]:
+    async def litellm_tools(self) -> list[ToolCallDefinition]:
         available_tools = await self.cached_available_tools()
 
         # LiteLLM takes the standard OpenAI-compatible tool call format

{kiln_ai-0.22.0 → kiln_ai-0.22.1}/kiln_ai/adapters/vector_store/lancedb_adapter.py

@@ -5,12 +5,7 @@ from pathlib import Path
 from typing import Any, Dict, List, Literal, Optional, Set, TypedDict
 
 from llama_index.core import StorageContext, VectorStoreIndex
-from llama_index.core.schema import (
-    BaseNode,
-    NodeRelationship,
-    RelatedNodeInfo,
-    TextNode,
-)
+from llama_index.core.schema import BaseNode, TextNode
 from llama_index.core.vector_stores.types import (
     VectorStoreQuery as LlamaIndexVectorStoreQuery,
 )
@@ -24,15 +19,19 @@ from kiln_ai.adapters.vector_store.base_vector_store_adapter import (
     SearchResult,
     VectorStoreQuery,
 )
+from kiln_ai.adapters.vector_store.lancedb_helpers import (
+    convert_to_llama_index_node,
+    deterministic_chunk_id,
+    lancedb_construct_from_config,
+    store_type_to_lancedb_query_type,
+)
 from kiln_ai.datamodel.rag import RagConfig
 from kiln_ai.datamodel.vector_store import (
     VectorStoreConfig,
-    VectorStoreType,
     raise_exhaustive_enum_error,
 )
 from kiln_ai.utils.config import Config
 from kiln_ai.utils.env import temporary_env
-from kiln_ai.utils.uuid import string_to_uuid
 
 logger = logging.getLogger(__name__)
 
@@ -48,6 +47,7 @@ class LanceDBAdapter(BaseVectorStoreAdapter):
         self,
         rag_config: RagConfig,
         vector_store_config: VectorStoreConfig,
+        lancedb_vector_store: LanceDBVectorStore | None = None,
     ):
         super().__init__(rag_config, vector_store_config)
         self.config_properties = self.vector_store_config.lancedb_properties
@@ -56,17 +56,15 @@ class LanceDBAdapter(BaseVectorStoreAdapter):
         if vector_store_config.lancedb_properties.nprobes is not None:
             kwargs["nprobes"] = vector_store_config.lancedb_properties.nprobes
 
-        self.lancedb_vector_store = LanceDBVectorStore(
-            mode="create",
-            uri=LanceDBAdapter.lancedb_path_for_config(rag_config),
-            query_type=self.query_type,
-            overfetch_factor=vector_store_config.lancedb_properties.overfetch_factor,
-            vector_column_name=vector_store_config.lancedb_properties.vector_column_name,
-            text_key=vector_store_config.lancedb_properties.text_key,
-            doc_id_key=vector_store_config.lancedb_properties.doc_id_key,
-            **kwargs,
+        # allow overriding the vector store with a custom one, useful for user loading into an arbitrary
+        # deployment
+        self.lancedb_vector_store = (
+            lancedb_vector_store
+            or lancedb_construct_from_config(
+                vector_store_config,
+                uri=LanceDBAdapter.lancedb_path_for_config(rag_config),
+            )
         )
-
         self._index = None
 
     @property
@@ -149,7 +147,7 @@ class LanceDBAdapter(BaseVectorStoreAdapter):
 
             chunk_count_for_document = len(chunks)
             deterministic_chunk_ids = [
-                self.compute_deterministic_chunk_id(document_id, chunk_idx)
+                deterministic_chunk_id(document_id, chunk_idx)
                 for chunk_idx in range(chunk_count_for_document)
             ]
 
@@ -176,42 +174,12 @@ class LanceDBAdapter(BaseVectorStoreAdapter):
                 zip(chunks_text, embeddings)
             ):
                 node_batch.append(
-                    TextNode(
-                        id_=deterministic_chunk_ids[chunk_idx],
+                    convert_to_llama_index_node(
+                        document_id=document_id,
+                        chunk_idx=chunk_idx,
+                        node_id=deterministic_chunk_id(document_id, chunk_idx),
                         text=chunk_text,
-                        embedding=embedding.vector,
-                        metadata={
-                            # metadata is populated by some internal llama_index logic
-                            # that uses for example the source_node relationship
-                            "kiln_doc_id": document_id,
-                            "kiln_chunk_idx": chunk_idx,
-                            #
-                            # llama_index lancedb vector store automatically sets these metadata:
-                            # "doc_id": "UUID node_id of the Source Node relationship",
-                            # "document_id": "UUID node_id of the Source Node relationship",
-                            # "ref_doc_id": "UUID node_id of the Source Node relationship"
-                            #
-                            # llama_index file loaders set these metadata, which would be useful to also support:
-                            # "creation_date": "2025-09-03",
-                            # "file_name": "file.pdf",
-                            # "file_path": "/absolute/path/to/the/file.pdf",
-                            # "file_size": 395154,
-                            # "file_type": "application\/pdf",
-                            # "last_modified_date": "2025-09-03",
-                            # "page_label": "1",
-                        },
-                        relationships={
-                            # when using the llama_index loaders, llama_index groups Nodes under Documents
-                            # and relationships point to the Document (which is also a Node), which confusingly
-                            # enough does not map to an actual file (for a PDF, a Document is a page of the PDF)
-                            # the Document structure is not something that is persisted, so it is fine here
-                            # if we have a relationship to a node_id that does not exist in the db
-                            NodeRelationship.SOURCE: RelatedNodeInfo(
-                                node_id=document_id,
-                                node_type="1",
-                                metadata={},
-                            ),
-                        },
+                        vector=embedding.vector,
                     )
                 )
 
@@ -330,10 +298,6 @@ class LanceDBAdapter(BaseVectorStoreAdapter):
                 return []
             raise
 
-    def compute_deterministic_chunk_id(self, document_id: str, chunk_idx: int) -> str:
-        # the id_ of the Node must be a UUID string, otherwise llama_index / LanceDB fails downstream
-        return str(string_to_uuid(f"{document_id}::{chunk_idx}"))
-
     async def count_records(self) -> int:
         try:
             table = self.lancedb_vector_store.table
@@ -346,15 +310,7 @@ class LanceDBAdapter(BaseVectorStoreAdapter):
 
     @property
     def query_type(self) -> Literal["fts", "hybrid", "vector"]:
-        match self.vector_store_config.store_type:
-            case VectorStoreType.LANCE_DB_FTS:
-                return "fts"
-            case VectorStoreType.LANCE_DB_HYBRID:
-                return "hybrid"
-            case VectorStoreType.LANCE_DB_VECTOR:
-                return "vector"
-            case _:
-                raise_exhaustive_enum_error(self.vector_store_config.store_type)
+        return store_type_to_lancedb_query_type(self.vector_store_config.store_type)
 
     @staticmethod
     def lancedb_path_for_config(rag_config: RagConfig) -> str:
@@ -380,9 +336,7 @@ class LanceDBAdapter(BaseVectorStoreAdapter):
                 kiln_doc_id = row["metadata"]["kiln_doc_id"]
                 if kiln_doc_id not in document_ids:
                     kiln_chunk_idx = row["metadata"]["kiln_chunk_idx"]
-                    record_id = self.compute_deterministic_chunk_id(
-                        kiln_doc_id, kiln_chunk_idx
-                    )
+                    record_id = deterministic_chunk_id(kiln_doc_id, kiln_chunk_idx)
                     rows_to_delete.append(record_id)
 
             if rows_to_delete:

kiln_ai-0.22.1/kiln_ai/adapters/vector_store/lancedb_helpers.py

@@ -0,0 +1,101 @@
+from typing import Any, Dict, List, Literal
+
+from llama_index.core.schema import NodeRelationship, RelatedNodeInfo, TextNode
+from llama_index.vector_stores.lancedb import LanceDBVectorStore
+
+from kiln_ai.datamodel.vector_store import (
+    VectorStoreConfig,
+    VectorStoreType,
+    raise_exhaustive_enum_error,
+)
+from kiln_ai.utils.uuid import string_to_uuid
+
+
+def store_type_to_lancedb_query_type(
+    store_type: VectorStoreType,
+) -> Literal["fts", "hybrid", "vector"]:
+    match store_type:
+        case VectorStoreType.LANCE_DB_FTS:
+            return "fts"
+        case VectorStoreType.LANCE_DB_HYBRID:
+            return "hybrid"
+        case VectorStoreType.LANCE_DB_VECTOR:
+            return "vector"
+        case _:
+            raise_exhaustive_enum_error(store_type)
+
+
+def lancedb_construct_from_config(
+    vector_store_config: VectorStoreConfig,
+    uri: str,
+    **extra_params: Any,
+) -> LanceDBVectorStore:
+    """Construct a LanceDBVectorStore from a VectorStoreConfig."""
+    kwargs: Dict[str, Any] = {**extra_params}
+    if (
+        vector_store_config.lancedb_properties.nprobes is not None
+        and "nprobes" not in kwargs
+    ):
+        kwargs["nprobes"] = vector_store_config.lancedb_properties.nprobes
+
+    return LanceDBVectorStore(
+        mode="create",
+        query_type=store_type_to_lancedb_query_type(vector_store_config.store_type),
+        overfetch_factor=vector_store_config.lancedb_properties.overfetch_factor,
+        vector_column_name=vector_store_config.lancedb_properties.vector_column_name,
+        text_key=vector_store_config.lancedb_properties.text_key,
+        doc_id_key=vector_store_config.lancedb_properties.doc_id_key,
+        uri=uri,
+        **kwargs,
+    )
+
+
+def convert_to_llama_index_node(
+    document_id: str,
+    chunk_idx: int,
+    node_id: str,
+    text: str,
+    vector: List[float],
+) -> TextNode:
+    return TextNode(
+        id_=node_id,
+        text=text,
+        embedding=vector,
+        metadata={
+            # metadata is populated by some internal llama_index logic
+            # that uses for example the source_node relationship
+            "kiln_doc_id": document_id,
+            "kiln_chunk_idx": chunk_idx,
+            #
+            # llama_index lancedb vector store automatically sets these metadata:
+            # "doc_id": "UUID node_id of the Source Node relationship",
+            # "document_id": "UUID node_id of the Source Node relationship",
+            # "ref_doc_id": "UUID node_id of the Source Node relationship"
+            #
+            # llama_index file loaders set these metadata, which would be useful to also support:
+            # "creation_date": "2025-09-03",
+            # "file_name": "file.pdf",
+            # "file_path": "/absolute/path/to/the/file.pdf",
+            # "file_size": 395154,
+            # "file_type": "application\/pdf",
+            # "last_modified_date": "2025-09-03",
+            # "page_label": "1",
+        },
+        relationships={
+            # when using the llama_index loaders, llama_index groups Nodes under Documents
+            # and relationships point to the Document (which is also a Node), which confusingly
+            # enough does not map to an actual file (for a PDF, a Document is a page of the PDF)
+            # the Document structure is not something that is persisted, so it is fine here
+            # if we have a relationship to a node_id that does not exist in the db
+            NodeRelationship.SOURCE: RelatedNodeInfo(
+                node_id=document_id,
+                node_type="1",
+                metadata={},
+            ),
+        },
+    )
+
+
+def deterministic_chunk_id(document_id: str, chunk_idx: int) -> str:
+    # the id_ of the Node must be a UUID string, otherwise llama_index / LanceDB fails downstream
+    return str(string_to_uuid(f"{document_id}::{chunk_idx}"))

{kiln_ai-0.22.0 → kiln_ai-0.22.1}/kiln_ai/adapters/vector_store/test_lancedb_adapter.py

@@ -17,6 +17,7 @@ from kiln_ai.adapters.vector_store.base_vector_store_adapter import (
     VectorStoreQuery,
 )
 from kiln_ai.adapters.vector_store.lancedb_adapter import LanceDBAdapter
+from kiln_ai.adapters.vector_store.lancedb_helpers import deterministic_chunk_id
 from kiln_ai.adapters.vector_store.vector_store_registry import (
     vector_store_adapter_for_config,
 )
@@ -925,9 +926,7 @@ async def test_get_nodes_by_ids_functionality(
     await adapter.add_chunks_with_embeddings([mock_chunked_documents[0]])  # doc_001
 
     # Test getting nodes by IDs - compute expected IDs
-    expected_ids = [
-        adapter.compute_deterministic_chunk_id("doc_001", i) for i in range(4)
-    ]
+    expected_ids = [deterministic_chunk_id("doc_001", i) for i in range(4)]
 
     # Get nodes by IDs
     retrieved_nodes = await adapter.get_nodes_by_ids(expected_ids)
@@ -943,7 +942,7 @@ async def test_get_nodes_by_ids_functionality(
         assert len(node.get_content()) > 0
 
     # Test with non-existent IDs
-    fake_ids = [adapter.compute_deterministic_chunk_id("fake_doc", i) for i in range(2)]
+    fake_ids = [deterministic_chunk_id("fake_doc", i) for i in range(2)]
     retrieved_fake = await adapter.get_nodes_by_ids(fake_ids)
     assert len(retrieved_fake) == 0
 
@@ -1019,7 +1018,7 @@ async def test_uuid_scheme_retrieval_and_node_properties(
     # Test the UUID scheme: document_id::chunk_idx
     for chunk_idx in range(4):
         # Compute expected ID using the same scheme as the adapter
-        expected_id = adapter.compute_deterministic_chunk_id("doc_001", chunk_idx)
+        expected_id = deterministic_chunk_id("doc_001", chunk_idx)
 
         # Retrieve the specific node by ID
         retrieved_nodes = await adapter.get_nodes_by_ids([expected_id])
@@ -1053,7 +1052,7 @@ async def test_uuid_scheme_retrieval_and_node_properties(
 
     # Test retrieval of doc_002 chunks
     for chunk_idx in range(4):
-        expected_id = adapter.compute_deterministic_chunk_id("doc_002", chunk_idx)
+        expected_id = deterministic_chunk_id("doc_002", chunk_idx)
         retrieved_nodes = await adapter.get_nodes_by_ids([expected_id])
         assert len(retrieved_nodes) == 1
 
@@ -1080,25 +1079,19 @@ async def test_deterministic_chunk_id_consistency(
     create_rag_config_factory,
 ):
     """Test that the deterministic chunk ID generation is consistent."""
-    rag_config = create_rag_config_factory(fts_vector_store_config, embedding_config)
-
-    adapter = LanceDBAdapter(
-        rag_config,
-        fts_vector_store_config,
-    )
 
     # Test that the same document_id and chunk_idx always produce the same UUID
     doc_id = "test_doc_123"
     chunk_idx = 5
 
-    id1 = adapter.compute_deterministic_chunk_id(doc_id, chunk_idx)
-    id2 = adapter.compute_deterministic_chunk_id(doc_id, chunk_idx)
+    id1 = deterministic_chunk_id(doc_id, chunk_idx)
+    id2 = deterministic_chunk_id(doc_id, chunk_idx)
 
     assert id1 == id2
 
     # Test that different inputs produce different UUIDs
-    id3 = adapter.compute_deterministic_chunk_id(doc_id, chunk_idx + 1)
-    id4 = adapter.compute_deterministic_chunk_id(doc_id + "_different", chunk_idx)
+    id3 = deterministic_chunk_id(doc_id, chunk_idx + 1)
+    id4 = deterministic_chunk_id(doc_id + "_different", chunk_idx)
 
     assert id1 != id3
     assert id1 != id4