Update context grounding vector store to be compatible with gym

Author: adrian-badea

src/uipath_langchain/vectorstores/context_grounding_vectorstore.py

@@ -11,57 +11,69 @@
 """
 
 from collections.abc import Iterable
-from typing import Any, Optional, TypeVar
+from typing import Any, Self, override
 
 from langchain_core.documents import Document
 from langchain_core.embeddings import Embeddings
 from langchain_core.vectorstores import VectorStore
 from uipath import UiPath
+from uipath._config import Config
+from uipath._execution_context import ExecutionContext
+from uipath._services.context_grounding_service import ContextGroundingService
+from uipath.models.context_grounding import ContextGroundingQueryResponse
 
-VST = TypeVar("VST", bound="ContextGroundingVectorStore")
+from uipath_agents_gym.tools.ecs.types import ECSMetadata
 
+VST = TypeVar("VST", bound="ContextGroundingVectorStore")
 
 class ContextGroundingVectorStore(VectorStore):
     """Vector store that uses UiPath Context Grounding (ECS) as a backend.
 
     This class provides a straightforward implementation that connects to the
     UiPath Context Grounding API for semantic searching.
-
-    Example:
-        .. code-block:: python
-
-            from uipath_agents_gym.tools.ecs_vectorstore import ContextGroundingVectorStore
-
-            # Initialize the vector store with an index name
-            vectorstore = ContextGroundingVectorStore(index_name="ECCN")
-
-            # Perform similarity search
-            docs_with_scores = vectorstore.similarity_search_with_score(
-                "How do I process an invoice?", k=5
-            )
     """
 
     def __init__(
         self,
         index_name: str,
-        folder_path: Optional[str] = None,
-        uipath_sdk: Optional[UiPath] = None,
+        uipath_url: str,
+        access_token: str,
+        folder_key: str | None = None,
+        folder_path: str | None = None,
     ):
         """Initialize the ContextGroundingVectorStore.
 
         Args:
-            index_name: Name of the context grounding index to use
-            uipath_sdk: Optional SDK instance to use. If not provided, a new instance will be created.
+            index_name: Name of the context grounding index to use (schema name)
+            uipath_url: UiPath URL (e.g., "https://alpha.uipath.com/organizationId/tenantId")
+            access_token: Static access token for authentication
+            folder_key: Optional folder key for folder-scoped operations
+            folder_path: Optional folder path for folder-scoped operations
         """
         self.index_name = index_name
+        self.uipath_url = uipath_url
+        self.folder_key = folder_key
         self.folder_path = folder_path
-        self.sdk = uipath_sdk or UiPath()
 
+        # Create Config and ExecutionContext with static token
+        config = Config(base_url=self.uipath_url, secret=access_token)
+        execution_context = ExecutionContext()
+
+        # Create a temporary UiPath SDK instance to get the required services
+        sdk = UiPath(base_url=self.uipath_url, secret=access_token)
+
+        # Create ContextGroundingService instance (composition over inheritance)
+        self._context_grounding_service = ContextGroundingService(
+            config, execution_context, sdk.folders, sdk.buckets
+        )
+
+    # VectorStore implementation methods
+
+    @override
     def similarity_search_with_score(
         self, query: str, k: int = 4, **kwargs: Any
     ) -> list[tuple[Document, float]]:
         """Return documents most similar to the query along with the distances.
-        The distance is 1 - score, where score is the relevance score returned by the Context Grounding API.
 
         Args:
             query: The query string
@@ -70,52 +82,23 @@ def similarity_search_with_score(
         Returns:
             list of tuples of (document, score)
         """
-        # Call the UiPath SDK to perform the search
-        results = self.sdk.context_grounding.search(
+        # Use the context grounding service to perform search
+        results: list[ContextGroundingQueryResponse] = self._context_grounding_service.search(
             name=self.index_name,
             query=query,
             number_of_results=k,
+            folder_key=self.folder_key,
             folder_path=self.folder_path,
         )
 
-        # Convert the results to Documents with scores
-        docs_with_scores = []
-        for result in results:
-            # Create metadata from result fields
-            metadata = {
-                "source": result.source,
-                "id": result.id,
-                "reference": result.reference,
-                "page_number": result.page_number,
-                "source_document_id": result.source_document_id,
-                "caption": result.caption,
-            }
-
-            # Add any operation metadata if available
-            if result.metadata:
-                metadata["operation_id"] = result.metadata.operation_id
-                metadata["strategy"] = result.metadata.strategy
-
-            # Create a Document with the content and metadata
-            doc = Document(
-                page_content=result.content,
-                metadata=metadata,
-            )
-
-            score = 1.0 - float(result.score)
-
-            docs_with_scores.append((doc, score))
-
-        return docs_with_scores
+        return self._convert_results_to_documents(results)
 
+    @override
     def similarity_search_with_relevance_scores(
         self, query: str, k: int = 4, **kwargs: Any
     ) -> list[tuple[Document, float]]:
         """Return documents along with their relevance scores on a scale from 0 to 1.
 
-        This directly uses the scores provided by the Context Grounding API,
-        which are already normalized between 0 and 1.
-
         Args:
             query: The query string
             k: Number of documents to return (default=4)
@@ -128,6 +111,7 @@ def similarity_search_with_relevance_scores(
             for doc, score in self.similarity_search_with_score(query, k, **kwargs)
         ]
 
+    @override
     async def asimilarity_search_with_score(
         self, query: str, k: int = 4, **kwargs: Any
     ) -> list[tuple[Document, float]]:
@@ -140,52 +124,24 @@ async def asimilarity_search_with_score(
         Returns:
             list of tuples of (document, score)
         """
-        # Call the UiPath SDK to perform the search asynchronously
-        results = await self.sdk.context_grounding.search_async(
+        # Use the context grounding service to perform async search
+        results: list[
+            ContextGroundingQueryResponse
+        ] = await self._context_grounding_service.search_async(
             name=self.index_name,
             query=query,
             number_of_results=k,
+            folder_key=self.folder_key,
             folder_path=self.folder_path,
         )
 
-        # Convert the results to Documents with scores
-        docs_with_scores = []
-        for result in results:
-            # Create metadata from result fields
-            metadata = {
-                "source": result.source,
-                "id": result.id,
-                "reference": result.reference,
-                "page_number": result.page_number,
-                "source_document_id": result.source_document_id,
-                "caption": result.caption,
-            }
-
-            # Add any operation metadata if available
-            if result.metadata:
-                metadata["operation_id"] = result.metadata.operation_id
-                metadata["strategy"] = result.metadata.strategy
-
-            # Create a Document with the content and metadata
-            doc = Document(
-                page_content=result.content,
-                metadata=metadata,
-            )
-
-            # Get the distance score as 1 - ecs_score
-            score = 1.0 - float(result.score)
-
-            docs_with_scores.append((doc, score))
-
-        return docs_with_scores
+        return self._convert_results_to_documents(results)
 
+    @override
     async def asimilarity_search_with_relevance_scores(
         self, query: str, k: int = 4, **kwargs: Any
     ) -> list[tuple[Document, float]]:
-        """Asynchronously return documents along with their relevance scores on a scale from 0 to 1.
-
-        This directly uses the scores provided by the Context Grounding API,
-        which are already normalized between 0 and 1.
+        """Asynchronously return documents along with their relevance scores.
 
         Args:
             query: The query string
@@ -196,14 +152,11 @@ async def asimilarity_search_with_relevance_scores(
         """
         return [
             (doc, 1.0 - score)
-            for doc, score in await self.asimilarity_search_with_score(
-                query, k, **kwargs
-            )
+            for doc, score in await self.asimilarity_search_with_score(query, k, **kwargs)
         ]
 
-    def similarity_search(
-        self, query: str, k: int = 4, **kwargs: Any
-    ) -> list[Document]:
+    @override
+    def similarity_search(self, query: str, k: int = 4, **kwargs: Any) -> list[Document]:
         """Return documents most similar to the query.
 
         Args:
@@ -216,9 +169,8 @@ def similarity_search(
         docs_and_scores = self.similarity_search_with_score(query, k, **kwargs)
         return [doc for doc, _ in docs_and_scores]
 
-    async def asimilarity_search(
-        self, query: str, k: int = 4, **kwargs: Any
-    ) -> list[Document]:
+    @override
+    async def asimilarity_search(self, query: str, k: int = 4, **kwargs: Any) -> list[Document]:
         """Asynchronously return documents most similar to the query.
 
         Args:
@@ -231,14 +183,67 @@ async def asimilarity_search(
         docs_and_scores = await self.asimilarity_search_with_score(query, k, **kwargs)
         return [doc for doc, _ in docs_and_scores]
 
+    def _convert_results_to_documents(
+        self, results: list[ContextGroundingQueryResponse]
+    ) -> list[tuple[Document, float]]:
+        """Convert API results to Document objects with scores.
+
+        Args:
+            results: List of ContextGroundingQueryResponse objects
+
+        Returns:
+            List of tuples containing (Document, score)
+        """
+        docs_with_scores = []
+
+        for result in results:
+            # Create metadata from result fields using Pydantic model
+            metadata_dict = {}
+
+            # Add required string fields with proper defaults
+            if result.source:
+                metadata_dict["source"] = str(result.source)
+            if result.reference:
+                metadata_dict["reference"] = str(result.reference)
+            if result.page_number:
+                metadata_dict["page_number"] = str(result.page_number)
+            if result.source_document_id:
+                metadata_dict["source_document_id"] = str(result.source_document_id)
+            if result.caption:
+                metadata_dict["caption"] = str(result.caption)
+
+            # Add any operation metadata if available
+            if result.metadata:
+                if result.metadata.operation_id:
+                    metadata_dict["operation_id"] = str(result.metadata.operation_id)
+                if result.metadata.strategy:
+                    metadata_dict["strategy"] = str(result.metadata.strategy)
+
+            # Create and validate metadata using Pydantic model
+            metadata = ECSMetadata(**metadata_dict)
+
+            # Create a Document with the content and metadata
+            doc = Document(
+                page_content=result.content or "",
+                metadata=metadata.model_dump(exclude_none=True),
+            )
+
+            # Convert score to distance (1 - score)
+            score = 1.0 - float(result.score or 0.0)
+
+            docs_with_scores.append((doc, score))
+
+        return docs_with_scores
+
     @classmethod
+    @override
     def from_texts(
-        cls: type[VST],
+        cls,
         texts: list[str],
         embedding: Embeddings,
-        metadatas: Optional[list[dict[str, Any]]] = None,
+        metadatas: list[dict] | None = None,
         **kwargs: Any,
-    ) -> VST:
+    ) -> Self:
         """This method is required by the VectorStore abstract class, but is not supported
         by ContextGroundingVectorStore which is read-only.
 
@@ -247,22 +252,20 @@ def from_texts(
         """
         raise NotImplementedError(
             "ContextGroundingVectorStore is a read-only wrapper for UiPath Context Grounding. "
-            "Creating a vector store from texts is not supported."
+            + "Creating a vector store from texts is not supported."
         )
 
-    # Other required methods with minimal implementation to satisfy the interface
+    @override
     def add_texts(
-        self,
-        texts: Iterable[str],
-        metadatas: Optional[list[dict[str, Any]]] = None,
-        **kwargs: Any,
+        self, texts: Iterable[str], metadatas: list[dict] | None = None, **kwargs: Any
     ) -> list[str]:
         """Not implemented for ContextGroundingVectorStore as this is a read-only wrapper."""
         raise NotImplementedError(
             "ContextGroundingVectorStore is a read-only wrapper for UiPath Context Grounding."
-        )
+        ) # type: ignore[unreachable]
 
-    def delete(self, ids: Optional[list[str]] = None, **kwargs: Any) -> Optional[bool]:
+    @override
+    def delete(self, ids: list[str] | None = None, **kwargs: Any) -> bool | None:
         """Not implemented for ContextGroundingVectorStore as this is a read-only wrapper."""
         raise NotImplementedError(
             "ContextGroundingVectorStore is a read-only wrapper for UiPath Context Grounding."