uipath-langchain 0.0.101__tar.gz → 0.0.102__tar.gz

{uipath_langchain-0.0.101 → uipath_langchain-0.0.102}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: uipath-langchain
-Version: 0.0.101
+Version: 0.0.102
 Summary: UiPath Langchain
 Project-URL: Homepage, https://uipath.com
 Project-URL: Repository, https://github.com/UiPath/uipath-langchain-python

uipath_langchain-0.0.101/docs/context_grounding_retriever.md → uipath_langchain-0.0.102/docs/context_grounding.md

@@ -1,10 +1,6 @@
-# ContextGroundingRetriever
-
-The `ContextGroundingRetriever` is a document retrieval system that uses vector search to efficiently find and retrieve relevant information from your document store.
-
-## Overview
+# Context Grounding
 
-`ContextGroundingRetriever` allows you to:
+Context Grounding Service allows you to:
 - Search through indexed documents using natural language queries
 - Ground LLM responses in your organization's specific information
 - Retrieve context-relevant documents for various applications
@@ -12,6 +8,11 @@ The `ContextGroundingRetriever` is a document retrieval system that uses vector
 
 You will need to create an index in `Context Grounding` to use this feature. To create an index go to organization `Admin` -> `AI Trust Layer` -> `Context Grounding`. There you can create a new index and add documents to it. See the full documentation [here](https://docs.uipath.com/automation-cloud/automation-cloud/latest/admin-guide/about-context-grounding) for more details.
 
+
+# ContextGroundingRetriever
+
+The `ContextGroundingRetriever` is a document retrieval system that uses vector search to efficiently find and retrieve relevant information from your document store.
+
 ## Basic Usage
 
 Create a simple retriever by specifying an index name:
@@ -51,4 +52,39 @@ agent = create_react_agent(model, tools, prompt="Answer user questions as best a
 
 ## Advanced Usage
 
-For complex applications, the retriever can be combined with other LangChain components to create robust document QA systems, agents, or knowledge bases.
+For complex applications, the retriever can be combined with other LangChain components to create robust document QA systems, agents, or knowledge bases.
+
+
+
+# ContextGroundingVectorStore
+
+`ContextGroundingVectorStore` is a vector store implementation designed for context-aware document retrieval. It allows you to perform semantic searches and create retrieval chains with language models.
+
+## Searching Documents
+
+The vector store supports various search methods:
+
+```python
+from uipath_langchain.vectorstores.context_grounding_vectorstore import ContextGroundingVectorStore
+
+vectorstore = ContextGroundingVectorStore(index_name="Company policy")
+
+# Perform semantic searches with distance scores
+docs_with_scores = vectorstore.asimilarity_search_with_score(query="What is the company policy on data storage?", k=5)
+
+# Perform a similarity search with relevance scores
+docs_with_relevance_scores = await vectorstore.asimilarity_search_with_relevance_scores(query=query, k=5)
+```
+
+## Creating a Retrieval Chain
+
+You can integrate the vector store into a retrieval chain with a language model:
+
+```python
+# Run a retrieval chain
+model = UiPathAzureChatOpenAI(model="gpt-4o-2024-08-06", max_retries=3)
+retrieval_chain = create_retrieval_chain(vectorstore=vectorstore, model=model)
+
+query = "What is the ECCN for a laptop?"
+result = retrieval_chain(query)
+```

{uipath_langchain-0.0.101 → uipath_langchain-0.0.102}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "uipath-langchain"
-version = "0.0.101"
+version = "0.0.102"
 description = "UiPath Langchain"
 readme = { file = "README.md", content-type = "text/markdown" }
 requires-python = ">=3.10"

{uipath_langchain-0.0.101 → uipath_langchain-0.0.102}/src/uipath_langchain/_cli/_runtime/_runtime.py

@@ -80,9 +80,6 @@ class LangGraphRuntime(UiPathBaseRuntime):
 
                 if self.context.job_id and self.context.tracing_enabled:
                     tracer = AsyncUiPathTracer(context=self.context.trace_context)
-                    await tracer.init_trace(
-                        self.context.entrypoint, self.context.job_id
-                    )
                     callbacks = [tracer]
 
                 graph_config: RunnableConfig = {

{uipath_langchain-0.0.101 → uipath_langchain-0.0.102}/src/uipath_langchain/tracers/AsyncUiPathTracer.py

@@ -2,7 +2,6 @@ import asyncio
 import json
 import logging
 import queue
-import re
 import uuid
 import warnings
 from os import environ as env
@@ -43,9 +42,7 @@ class AsyncUiPathTracer(AsyncBaseTracer):
 
         self.context = context or UiPathTraceContext()
 
-        llm_ops_pattern = self._get_base_url() + "{orgId}/llmops_"
-
-        self.url = llm_ops_pattern.format(orgId=self.context.org_id).rstrip("/")
+        self.base_url = self._get_base_url()
 
         auth_token = env.get("UNATTENDED_USER_ACCESS_TOKEN") or env.get(
             "UIPATH_ACCESS_TOKEN"
@@ -103,44 +100,6 @@ class AsyncUiPathTracer(AsyncBaseTracer):
                     )
                     self._send_span(previous_run)
 
-    async def init_trace(self, run_name, trace_id=None) -> None:
-        if self.context.trace_id:
-            # trace id already set no need to do anything
-            return
-
-        # no trace id, start a new trace
-        await self.start_trace(run_name, trace_id)
-
-    async def start_trace(self, run_name, trace_id=None) -> None:
-        self.context.trace_id = str(uuid.uuid4())
-
-        run_name = run_name or f"Job Run: {self.context.trace_id}"
-        trace_data = {
-            "id": self.context.trace_id,
-            "name": re.sub(
-                r"[!@#$<>\.]", "", run_name
-            ),  # if we use these characters the Agents UI throws some error (but llmops backend seems fine)
-            "referenceId": self.context.reference_id,
-            "attributes": "{}",
-            "organizationId": self.context.org_id,
-            "tenantId": self.context.tenant_id,
-        }
-
-        for attempt in range(self.retries):
-            response = await self.client.post(
-                f"{self.url}/api/Agent/trace/", headers=self.headers, json=trace_data
-            )
-
-            if response.is_success:
-                break
-
-            await asyncio.sleep(0.5 * (2**attempt))  # Exponential backoff
-
-        if 400 <= response.status_code < 600:
-            logger.warning(
-                f"Error when sending trace: {response}. Body is: {response.text}"
-            )
-
     async def wait_for_all_tracers(self) -> None:
         """
         Wait for all pending log requests to complete
@@ -159,11 +118,13 @@ class AsyncUiPathTracer(AsyncBaseTracer):
 
                 span_data = self.log_queue.get_nowait()
 
+                url = self._build_url(self.context.trace_id)
+
                 for attempt in range(self.retries):
                     response = await self.client.post(
-                        f"{self.url}/api/Agent/span/",
+                        url,
                         headers=self.headers,
-                        json=span_data,
+                        json=[span_data],  # api expects a list of spans
                         timeout=10,
                     )
 
@@ -189,11 +150,12 @@ class AsyncUiPathTracer(AsyncBaseTracer):
                     break
 
                 span_data = self.log_queue.get_nowait()
+                url = self._build_url(self.context.trace_id)
 
                 response = await self.client.post(
-                    f"{self.url}/api/Agent/span/",
+                    url,
                     headers=self.headers,
-                    json=span_data,
+                    json=[span_data],  # api expects a list of spans
                     timeout=10,
                 )
             except Exception as e:
@@ -239,6 +201,7 @@ class AsyncUiPathTracer(AsyncBaseTracer):
                 "jobKey": self.context.job_id,
                 "folderKey": self.context.folder_key,
                 "processKey": self.context.folder_key,
+                "expiryTimeUtc": None,
             }
 
             self.log_queue.put(span_data)
@@ -293,16 +256,11 @@ class AsyncUiPathTracer(AsyncBaseTracer):
         uipath_url = (
             env.get("UIPATH_URL") or "https://cloud.uipath.com/dummyOrg/dummyTennant/"
         )
-        uipath_url = uipath_url.rstrip("/")
 
-        # split by "//" to get ['', 'https:', 'alpha.uipath.com/ada/byoa']
-        parts = uipath_url.split("//")
-
-        # after splitting by //, the base URL will be at index 1 along with the rest,
-        # hence split it again using "/" to get ['https:', 'alpha.uipath.com', 'ada', 'byoa']
-        base_url_parts = parts[1].split("/")
+        uipath_url = uipath_url.rstrip("/")
 
-        # combine scheme and netloc to get the base URL
-        base_url = parts[0] + "//" + base_url_parts[0] + "/"
+        return uipath_url
 
-        return base_url
+    def _build_url(self, trace_id: Optional[str]) -> str:
+        """Construct the URL for the API request."""
+        return f"{self.base_url}/llmopstenant_/api/Traces/spans?traceId={trace_id}&source=Robots"

uipath_langchain-0.0.102/tests/tracers/test_async_uipath_tracer.py

@@ -0,0 +1,366 @@
+import uuid
+from datetime import datetime
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+from langchain_core.tracers.schemas import Run
+from uipath._cli._runtime._contracts import UiPathTraceContext
+
+from uipath_langchain.tracers._events import CustomTraceEvents, FunctionCallEventData
+from uipath_langchain.tracers.AsyncUiPathTracer import AsyncUiPathTracer, Status
+
+
+class TestAsyncUiPathTracer:
+    @pytest.fixture
+    def mock_response(self):
+        response = AsyncMock()
+        response.is_success = True
+        response.status_code = 200
+        response.text = "Success"
+        return response
+
+    @pytest.fixture
+    def mock_client(self, mock_response):
+        client = AsyncMock()
+        client.post.return_value = mock_response
+        return client
+
+    @pytest.fixture
+    def mock_context(self):
+        context = UiPathTraceContext()
+        context.trace_id = "test-trace-id"
+        context.parent_span_id = "test-parent-span-id"
+        context.org_id = "test-org-id"
+        context.tenant_id = "test-tenant-id"
+        context.job_id = "test-job-id"
+        context.folder_key = "test-folder-key"
+        context.reference_id = "test-reference-id"
+        return context
+
+    @pytest.fixture
+    def tracer(self, mock_client, mock_context):
+        # Don't create any real asyncio tasks in fixtures
+        with patch("asyncio.create_task"):
+            with patch.dict("os.environ", {"UIPATH_ACCESS_TOKEN": "test-token"}):
+                # Instantiate the tracer but don't start the worker
+                tracer = AsyncUiPathTracer(context=mock_context, client=mock_client)
+
+                # Set worker_task to a mock that can be awaited
+                mock_task = AsyncMock()
+                tracer.worker_task = mock_task
+
+                # Set running to False to avoid worker logic
+                tracer.running = False
+
+                yield tracer
+
+    @pytest.mark.asyncio
+    async def test_init(self, tracer, mock_client, mock_context):
+        # We only verify non-task related initialization
+        assert tracer.client == mock_client
+        assert tracer.context == mock_context
+        assert tracer.headers == {"Authorization": "Bearer test-token"}
+        assert tracer.running is False
+
+    @pytest.mark.asyncio
+    async def test_persist_run(self, tracer):
+        # Mock the _send_span method
+        tracer._send_span = MagicMock()
+
+        # Create a run with datetime for start_time
+        run = Run(
+            id=uuid.uuid4(),
+            name="test_run",
+            start_time=datetime(2023, 1, 1, 0, 0, 0),
+            run_type="llm",
+            inputs={"prompt": "test"},
+        )
+
+        # Call _persist_run
+        await tracer._persist_run(run)
+
+        # Verify _send_span was called with the run
+        tracer._send_span.assert_called_once_with(run)
+
+    @pytest.mark.asyncio
+    async def test_send_span(self, tracer):
+        # Create a run
+        run_id = uuid.uuid4()
+        run = Run(
+            id=run_id,
+            name="test_run",
+            start_time=datetime(2023, 1, 1, 0, 0, 0),
+            end_time=datetime(2023, 1, 1, 0, 1, 0),
+            run_type="llm",
+            inputs={"prompt": "test"},
+            outputs={"result": "output"},
+            error=None,  # Make it explicit that there's no error
+        )
+
+        # Call _send_span without mocking its internal methods
+        tracer._send_span(run)
+
+        # Get the item from the queue
+        span_data = tracer.log_queue.get_nowait()
+
+        # Verify expected data was put in the queue
+        assert span_data["id"] == str(run_id)
+        assert span_data["name"] == "test_run"
+        assert span_data["traceId"] == tracer.context.trace_id
+        assert span_data["parentId"] == tracer.context.parent_span_id
+        assert (
+            span_data["startTime"] == "2023-01-01T00:00:00"
+        )  # Serialized to ISO format
+        assert span_data["endTime"] == "2023-01-01T00:01:00"  # Serialized to ISO format
+        assert span_data["status"] == Status.SUCCESS  # Since error is None
+        assert (
+            "attributes" in span_data
+        )  # Just verify it exists, don't check exact content
+        assert span_data["spanType"] == "LangGraphRun"
+
+    @pytest.mark.asyncio
+    async def test_on_custom_event_function_call(self, tracer):
+        # Instead of modifying the Run object, we'll patch the entire Run.create_child method
+        # at the module level
+        child_run = Run(
+            id=uuid.uuid4(),
+            name="function_call",
+            run_type="tool",
+            inputs={"arg": "value"},
+            start_time=datetime(2023, 1, 1, 0, 0, 0),
+        )
+
+        # Create a run
+        run_id = uuid.uuid4()
+        parent_run = Run(
+            id=run_id,
+            name="parent_run",
+            run_type="chain",
+            inputs={},
+            start_time=datetime(2023, 1, 1, 0, 0, 0),
+        )
+
+        # Add the run to the run_map
+        tracer.run_map[str(run_id)] = parent_run
+
+        # Mock _send_span method
+        tracer._send_span = MagicMock()
+
+        # Patch the RunTree create_child in langsmith
+        with patch(
+            "langchain_core.tracers.schemas.Run.create_child", return_value=child_run
+        ) as mock_create_child:
+            # Create function call event data
+            call_uuid = "test-call-uuid"
+            event_data = FunctionCallEventData(
+                call_uuid=call_uuid,
+                event_type="call",
+                function_name="test_function",
+                run_type="tool",
+                inputs={"arg": "value"},
+                tags=["test-tag"],
+                metadata={"meta": "data"},
+                output=None,
+                error=None,
+            )
+
+            # Call on_custom_event
+            await tracer.on_custom_event(
+                name=CustomTraceEvents.UIPATH_TRACE_FUNCTION_CALL,
+                data=event_data,
+                run_id=run_id,
+            )
+
+            # Verify the patched create_child was called with correct arguments
+            mock_create_child.assert_called_once_with(
+                name="test_function",
+                run_type="tool",
+                tags=["test-tag"],
+                inputs={"arg": "value"},
+            )
+
+            # Verify _send_span was called
+            tracer._send_span.assert_called_once()
+
+            # Verify function_call_run_map was updated
+            assert call_uuid in tracer.function_call_run_map
+            assert tracer.function_call_run_map[call_uuid] == child_run
+
+    @pytest.mark.asyncio
+    async def test_on_custom_event_function_completion(self, tracer):
+        # Create a function call run
+        call_uuid = "test-call-uuid"
+        child_run = Run(
+            id=uuid.uuid4(),
+            name="function_call",
+            run_type="function",
+            inputs={"arg": "value"},
+            start_time=datetime(2023, 1, 1, 0, 0, 0),
+        )
+
+        # Add the run to the function_call_run_map
+        tracer.function_call_run_map[call_uuid] = child_run
+
+        # Mock _send_span method and _safe_dict_dump
+        tracer._send_span = MagicMock()
+        tracer._safe_dict_dump = MagicMock(return_value={"result": "output"})
+
+        # Create function completion event data
+        event_data = FunctionCallEventData(
+            call_uuid=call_uuid,
+            event_type="completion",
+            function_name="test_function",
+            output={"result": "output"},
+            error=None,
+            inputs={},
+        )
+
+        # Patch Run.end method since we can't modify the Run object directly
+        with patch("langchain_core.tracers.schemas.Run.end") as mock_end:
+            # Call on_custom_event
+            await tracer.on_custom_event(
+                name=CustomTraceEvents.UIPATH_TRACE_FUNCTION_CALL,
+                data=event_data,
+                run_id=uuid.uuid4(),
+            )
+
+            # Verify Run.end was called with the right arguments
+            mock_end.assert_called_once_with(outputs={"result": "output"}, error=None)
+
+            # Verify _send_span was called
+            tracer._send_span.assert_called_once_with(child_run)
+
+            # Verify run was removed from function_call_run_map
+            assert call_uuid not in tracer.function_call_run_map
+
+    @pytest.mark.asyncio
+    async def test_determine_status(self, tracer):
+        # Test success status
+        assert tracer._determine_status(None) == Status.SUCCESS
+
+        # Test error status
+        assert tracer._determine_status("Error message") == Status.ERROR
+
+        # Test interrupted status
+        assert tracer._determine_status("GraphInterrupt(reason)") == Status.INTERRUPTED
+
+    @pytest.mark.asyncio
+    async def test_build_url(self, tracer):
+        # Mock the _get_base_url method
+        tracer.base_url = "https://cloud.uipath.com/org/tenant"
+
+        # Call _build_url
+        url = tracer._build_url("test-trace-id")
+
+        # Verify the URL
+        assert (
+            url
+            == "https://cloud.uipath.com/org/tenant/llmopstenant_/api/Traces/spans?traceId=test-trace-id&source=Robots"
+        )
+
+    @pytest.mark.asyncio
+    async def test_wait_for_all_tracers(self, tracer):
+        # Instead of trying to await the mock directly, let's patch the wait_for_all_tracers method
+        # to avoid awaiting the worker_task
+
+        # Save the original method
+        original_method = tracer.wait_for_all_tracers
+
+        # Replace with our test version that doesn't await the task
+        async def test_wait_for_all_tracers():
+            tracer.running = False
+            # Just return, don't await the worker_task
+
+        # Patch the method
+        tracer.wait_for_all_tracers = test_wait_for_all_tracers
+
+        # Call our test method
+        await tracer.wait_for_all_tracers()
+
+        # Verify running is set to False
+        assert tracer.running is False
+
+        # Restore the original method
+        tracer.wait_for_all_tracers = original_method
+
+    @pytest.mark.asyncio
+    async def test_worker_functionality(self, mock_client, mock_response, mock_context):
+        # For testing the worker functionality, we'll manually set up the tracer
+        with patch("asyncio.create_task"):
+            with patch.dict("os.environ", {"UIPATH_ACCESS_TOKEN": "test-token"}):
+                with patch.dict(
+                    "os.environ", {"UIPATH_URL": "https://cloud.uipath.com/org/tenant"}
+                ):
+                    # Mock the client.post method
+                    mock_client.post = AsyncMock(return_value=mock_response)
+                    # Create a tracer without starting the worker
+                    tracer = AsyncUiPathTracer(context=mock_context, client=mock_client)
+                    tracer.running = (
+                        False  # Set running to False to ensure worker exits
+                    )
+
+                    # Configure test data
+                    expected_url = "https://cloud.uipath.com/org/tenant/llmopstenant_/api/Traces/spans?traceId=test-trace-id&source=Robots"
+
+                    # Add a test span to the queue
+                    span_data = {
+                        "id": "test-id",
+                        "name": "test-span",
+                        "traceId": "test-trace-id",
+                    }
+                    tracer.log_queue.put(span_data)
+
+                    # Call the worker method directly
+                    await tracer._worker()
+
+                    # Verify client.post was called correctly
+                    mock_client.post.assert_called_with(
+                        expected_url,
+                        headers=tracer.headers,
+                        json=[span_data],
+                        timeout=10,
+                    )
+
+    @pytest.mark.asyncio
+    async def test_httpx_post_with_correct_data(self, mock_client, mock_response):
+        # Create a context
+        context = UiPathTraceContext()
+        context.trace_id = "test-trace-id"
+        context.parent_span_id = "test-parent-span-id"
+
+        # Create a tracer with patch.dict to set the environment variables
+        with patch("asyncio.create_task"):
+            with patch.dict("os.environ", {"UIPATH_ACCESS_TOKEN": "test-token"}):
+                # Fix the patch path - we want to patch the method, not the import
+                with patch.object(
+                    AsyncUiPathTracer,
+                    "_get_base_url",
+                    return_value="https://test.uipath.com/org/tenant",
+                ):
+                    tracer = AsyncUiPathTracer(context=context, client=mock_client)
+                    tracer.running = (
+                        False  # Set running to False to ensure worker exits
+                    )
+
+                    # Create a span that will go in the queue
+                    span_data = {
+                        "id": "test-id",
+                        "name": "test-span",
+                        "traceId": "test-trace-id",
+                        "attributes": '{"key": "value"}',
+                    }
+
+                    # Add span to the queue
+                    tracer.log_queue.put(span_data)
+
+                    # Execute the worker directly
+                    await tracer._worker()
+
+                    # Verify the post was called with the right URL and data
+                    expected_url = "https://test.uipath.com/org/tenant/llmopstenant_/api/Traces/spans?traceId=test-trace-id&source=Robots"
+                    mock_client.post.assert_called_with(
+                        expected_url,
+                        headers={"Authorization": "Bearer test-token"},
+                        json=[span_data],
+                        timeout=10,
+                    )