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

uipath_langchain-0.0.101/.github/workflows/publish-dev.yml

@@ -0,0 +1,123 @@
+name: Publish Dev Build
+
+on:
+  pull_request:
+    types: [opened, synchronize, reopened, labeled]
+    secrets:
+      PYPI_TOKEN_NIGHTLY:
+        required: true
+
+
+jobs:
+  publish-dev:
+    runs-on: ubuntu-latest
+    
+    # Only run if PR has the build:dev label
+    if: contains(github.event.pull_request.labels.*.name, 'build:dev')
+    
+    steps:
+      - uses: actions/checkout@v4
+      
+      - uses: astral-sh/setup-uv@v5
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version-file: ".python-version"
+
+      - name: Setup venv
+        run: |
+          uv venv
+          uv sync --all-extras
+      
+      - name: Set development version
+        shell: pwsh
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          $pyprojcontent = Get-Content pyproject.toml -Raw
+
+          $PROJECT_NAME    = ($pyprojcontent | Select-String -Pattern '(?m)^\[(project|tool\.poetry)\][^\[]*?name\s*=\s*"([^"]*)"' -AllMatches).Matches[0].Groups[2].Value
+          $CURRENT_VERSION = ($pyprojcontent | Select-String -Pattern '(?m)^\[(project|tool\.poetry)\][^\[]*?version\s*=\s*"([^"]*)"' -AllMatches).Matches[0].Groups[2].Value
+          $NIGHTLY_NAME = "$PROJECT_NAME-nightly"
+
+
+          # Get PR number and run number with proper padding
+          $PR_NUM = [int]"${{ github.event.pull_request.number }}"
+          $PADDED_PR  = "{0:D5}" -f [int]"${{ github.event.pull_request.number }}"
+          $PADDED_RUN = "{0:D4}" -f [int]"${{ github.run_number }}"
+          $PADDED_NEXT_PR = "{0:D5}" -f ($PR_NUM + 1)
+
+          # Create version range strings for PR
+          $MIN_VERSION = "$CURRENT_VERSION.dev1$PADDED_PR" + "0000"
+          $MAX_VERSION = "$CURRENT_VERSION.dev1$PADDED_NEXT_PR" + "0000"
+
+          # Create unique dev version with PR number and run ID
+          $DEV_VERSION = "$CURRENT_VERSION.dev1$PADDED_PR$PADDED_RUN"
+
+          # Update version in pyproject.toml
+          (Get-Content pyproject.toml) -replace "version = `"$CURRENT_VERSION`"", "version = `"$DEV_VERSION`"" | Set-Content pyproject.toml
+          
+          # Update project name in pyproject.toml
+          (Get-Content pyproject.toml) -replace "name = `"$PROJECT_NAME`"", "name = `"$NIGHTLY_NAME`"" | Set-Content pyproject.toml
+
+          
+          Write-Output "Package version set to $DEV_VERSION"
+
+          $dependencyMessage = @"
+          ## Development Package
+
+          - Add this package as a dependency in your pyproject.toml:
+
+          ``````toml
+          [project]
+          dependencies = [
+            # Exact version:
+            "$NIGHTLY_NAME==$DEV_VERSION",
+            
+            # Any version from PR
+            "$NIGHTLY_NAME>=$MIN_VERSION,<$MAX_VERSION"
+          ]
+          ``````
+          "@
+
+          # Get the owner and repo from the GitHub repository
+          $owner = "${{ github.repository_owner }}"
+          $repo = "${{ github.repository }}".Split('/')[1]
+          $prNumber = $PR_NUM
+
+          # Get the current PR description
+          $prUri = "https://api.github.com/repos/$owner/$repo/pulls/$prNumber"
+          $headers = @{
+            Authorization = "token $env:GITHUB_TOKEN"
+            Accept = "application/vnd.github.v3+json"
+          }
+          
+          $pr = Invoke-RestMethod -Uri $prUri -Method Get -Headers $headers
+          $currentBody = $pr.body
+
+          # Check if there's already a development package section
+          if ($currentBody -match '## Development Package') {
+            # Replace the existing section with the new dependency message
+            $newBody = $currentBody -replace '## Development Package(\r?\n|.)*?(?=##|$)', $dependencyMessage
+          } else {
+            # Append the dependency message to the end of the description
+            $newBody = if ($currentBody) { "$currentBody`n`n$dependencyMessage" } else { $dependencyMessage }
+          }
+
+          # Update the PR description
+          $updateBody = @{
+            body = $newBody
+          } | ConvertTo-Json
+
+          Invoke-RestMethod -Uri $prUri -Method Patch -Headers $headers -Body $updateBody -ContentType "application/json"
+          
+          Write-Output "Updated PR description with development package information"
+          
+      - name: Build package
+        run: uv build
+
+      - name: Publish
+        run: |
+          uv publish
+        env:
+          UV_PUBLISH_TOKEN: ${{ secrets.PYPI_TOKEN_NIGHTLY }}

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: uipath-langchain
-Version: 0.0.99
+Version: 0.0.101
 Summary: UiPath Langchain
 Project-URL: Homepage, https://uipath.com
 Project-URL: Repository, https://github.com/UiPath/uipath-langchain-python
@@ -25,7 +25,7 @@ Requires-Dist: pydantic-settings>=2.6.0
 Requires-Dist: python-dotenv>=1.0.1
 Requires-Dist: requests>=2.23.3
 Requires-Dist: types-requests>=2.32.0.20241016
-Requires-Dist: uipath<2.1.0,>=2.0.28
+Requires-Dist: uipath<2.1.0,>=2.0.31
 Provides-Extra: langchain
 Description-Content-Type: text/markdown
 
@@ -38,6 +38,8 @@ A Python SDK that enables developers to build and deploy LangGraph agents to the
 
 This package is an extension to the [UiPath Python SDK](https://github.com/UiPath/uipath-python).
 
+This [quickstart guide](docs/quick_start.md) walks you through deploying your first agent to UiPath Cloud Platform.
+
 ## Requirements
 
 - Python 3.10 or higher

{uipath_langchain-0.0.99 → uipath_langchain-0.0.101}/README.md

@@ -7,6 +7,8 @@ A Python SDK that enables developers to build and deploy LangGraph agents to the
 
 This package is an extension to the [UiPath Python SDK](https://github.com/UiPath/uipath-python).
 
+This [quickstart guide](docs/quick_start.md) walks you through deploying your first agent to UiPath Cloud Platform.
+
 ## Requirements
 
 - Python 3.10 or higher

uipath_langchain-0.0.99/docs/interrupt_models.md → uipath_langchain-0.0.101/docs/human_in_the_loop.md

@@ -1,81 +1,83 @@
-# UiPath Interrupt Models
+# Human In The Loop
 
-This README offers a detailed examination of the interrupt context models used within the UiPath-Langchain integration.
+Guide for **Human-In-The-Loop** scenarios within the UiPath-Langchain integration.
 It focuses on the **interrupt(model)** functionality, illustrating its role as a symbolic representation of an agent's
 wait state within the Langchain framework.
-These models function as integral components in enhancing the streamlined synchronization between the services of the
-UiPath platform and the Langchain coded agents.
+
+
 ## Models Overview
 
-### 1. InvokeProcess
 
-The `InvokeProcess` model is utilized to invoke a process within the UiPath cloud platform.
-This process can be of various types, including API workflows, Agents or RPA automation.
-Upon completion of the invoked process, the current agent will automatically resume execution.
+### 1. CreateAction
+
+The `CreateAction` model is utilized to create an escalation action within the UiPath Action Center as part of an interrupt context. The action will rely on a previously created UiPath app.
+After addressing the escalation, the current agent will resume execution.
+For more information on UiPath apps, refer to the [UiPath Apps User Guide](https://docs.uipath.com/apps/automation-cloud/latest/user-guide/introduction).
 
 #### Attributes:
-- **name** (str): The name of the process to invoke.
-- **input_arguments** (Optional[Dict[str, Any]]): A dictionary containing the input arguments required for the invoked process.
+- **name** (Optional[str]): The name of the app.
+- **key** (Optional[str]): The key of the app.
+- **title** (str): The title of the action to create.
+- **data** (Optional[Dict[str, Any]]): Values that the action will be populated with.
+- **app_version** (Optional[int]): The version of the app (defaults to 1).
+- **assignee** (Optional[str]): The username or email of the person assigned to handle the escalation.
 
 #### Example:
 ```python
-from uipath.models import InvokeProcess
-process_output = interrupt(InvokeProcess(name="MyProcess", input_arguments={"arg1": "value1"}))
+from uipath.models import CreateAction
+action_output = interrupt(CreateAction(name="AppName", title="Escalate Issue", data={"key": "value"}, app_version=1, assignee="user@example.com"))
 ```
-
-For a practical implementation of the `InvokeProcess` model, refer to the sample usage in the [planner.py](../samples/multi-agent-planner-researcher-coder-distributed/src/multi-agent-distributed/planner.py#L181) file. This example demonstrates how to invoke a process with dynamic input arguments, showcasing the integration of the interrupt functionality within a multi-agent system or a system where an agent integrates with RPA processes and API workflows.
+For a practical implementation of the `CreateAction` model, refer to the [ticket-classification sample](https://github.com/UiPath/uipath-langchain-python/tree/main/samples/ticket-classification). This sample demonstrates how to create an action with dynamic input.
 
 ---
 
-### 2. WaitJob
+### 2. WaitAction
 
-The `WaitJob` model is used to wait for a job completion. Unlike `InvokeProcess`, which automatically creates a job, this model is intended for scenarios where
-    the job has already been created.
+The `WaitAction` model is used to wait for an action to be handled. This model is intended for scenarios where the action has already been created.
 
 #### Attributes:
-- **job** (Job): The instance of the job that the agent will wait for. This should be a valid job object that has been previously created.
+- **action** (Action): The instance of the action to wait for.
 
 #### Example:
 ```python
-from uipath.models import WaitJob
-job_output = interrupt(WaitJob(job=my_job_instance))
+from uipath.models import WaitAction
+action_output = interrupt(WaitAction(action=my_action_instance))
 ```
-
 ---
+> 💡 UiPath Langchain sdk also supports **Robot/Agent-in-the-loop** scenarios. In this context, the execution of one agent
+> can be suspended until another robot or agent finishes its execution.
 
-### 3. CreateAction
+### 3. InvokeProcess
 
-The `CreateAction` model is utilized to create an escalation action within the UiPath Action Center as part of an interrupt context. The action will rely on a previously created UiPath app.
-After addressing the escalation, the current agent will resume execution.
-For more information on UiPath apps, refer to the [UiPath Apps User Guide](https://docs.uipath.com/apps/automation-cloud/latest/user-guide/introduction).
+The `InvokeProcess` model is utilized to invoke a process within the UiPath cloud platform.
+This process can be of various types, including API workflows, Agents or RPA automation.
+Upon completion of the invoked process, the current agent will automatically resume execution.
 
 #### Attributes:
-- **name** (Optional[str]): The name of the app.
-- **key** (Optional[str]): The key of the app.
-- **title** (str): The title of the action to create.
-- **data** (Optional[Dict[str, Any]]): Values that the action will be populated with.
-- **app_version** (Optional[int]): The version of the app (defaults to 1).
-- **assignee** (Optional[str]): The username or email of the person assigned to handle the escalation.
+- **name** (str): The name of the process to invoke.
+- **input_arguments** (Optional[Dict[str, Any]]): A dictionary containing the input arguments required for the invoked process.
 
 #### Example:
 ```python
-from uipath.models import CreateAction
-action_output = interrupt(CreateAction(name="AppName", title="Escalate Issue", data={"key": "value"}, app_version=1, assignee="user@example.com"))
+from uipath.models import InvokeProcess
+process_output = interrupt(InvokeProcess(name="MyProcess", input_arguments={"arg1": "value1"}))
 ```
-For a practical implementation of the `CreateAction` model, refer to the sample usage in the [ticket-classification/main.py](../samples/ticket-classification/main.py#L116) file. This example demonstrates how to create an action with dynamic input.
+
+For a practical implementation of the `InvokeProcess` model, refer to the [multi-agent-planner-researcher-coder-distributed sample](https://github.com/UiPath/uipath-langchain-python/tree/main/samples/multi-agent-planner-researcher-coder-distributed). This sample demonstrates how to invoke a process with dynamic input arguments, showcasing the integration of the interrupt functionality within a multi-agent system or a system where an agent integrates with RPA processes and API workflows.
 
 ---
 
-### 4. WaitAction
+### 4. WaitJob
 
-The `WaitAction` model is used to wait for an action to be handled. This model is intended for scenarios where the action has already been created.
+The `WaitJob` model is used to wait for a job completion. Unlike `InvokeProcess`, which automatically creates a job, this model is intended for scenarios where
+    the job has already been created.
 
 #### Attributes:
-- **action** (Action): The instance of the action to wait for.
+- **job** (Job): The instance of the job that the agent will wait for. This should be a valid job object that has been previously created.
 
 #### Example:
 ```python
-from uipath.models import WaitAction
-action_output = interrupt(WaitAction(action=my_action_instance))
+from uipath.models import WaitJob
+job_output = interrupt(WaitJob(job=my_job_instance))
 ```
 

uipath_langchain-0.0.101/docs/quick_start.md

@@ -0,0 +1,151 @@
+# Quickstart Guide: UiPath LangChain Agents
+
+## Introduction
+
+This guide walks you through the process of setting up, creating, publishing, and running your first UiPath-LangChain Agent.
+
+## Prerequisites
+
+Ensure you have the following installed before proceeding:
+
+-   Python 3.10 or higher
+-   `pip` or `uv` package manager
+-   A UiPath Platform account with appropriate permissions
+-   Either Anthropic or OpenAI API key
+
+### (Optional) Generating API keys
+
+> If you already have either an Anthropic or OpenAi API key you can skip this section.
+1. **Anthropic** -  Generate an Anthropic API key [here](https://console.anthropic.com/settings/keys).
+2. **OpenAi** - Generate an OpenAI API key [here](https://platform.openai.com).
+
+## Step-by-Step Guide
+
+## Creating a New Project
+
+We recommend using `uv` for package management. To create a new project:
+
+```shell
+mkdir example
+cd example
+uv init . --python 3.10
+```
+This command creates a basic project structure.
+
+## Install the UiPath LangChain SDK
+
+Add the UiPath LangChain SDK to your project:
+
+```bash
+uv add uipath[langchain]
+```
+To verify the installation, run:
+
+```shell
+ uv run uipath -lv
+```
+
+## (Optional) Activate your virtual environment
+```shell
+# Windows
+.venv\Scripts\activate
+```
+or
+```shell
+# Unix-like Systems
+source .venv/bin/activate
+```
+> If you skip activating the virtual environment, prefix the upcoming commands with `uv run`.
+
+
+## Create Your First UiPath Agent
+
+Generate your first UiPath LangChain:
+
+```bash
+uipath new my-agent
+```
+This command creates the following files:
+
+| File Name        | Description                                                                                                                       |
+|------------------|-----------------------------------------------------------------------------------------------------------------------------------|
+| `.env`           | Environment variables and secrets (this file will not be packed & published).                                                     |
+| `main.py`        | LangGraph agent code.                                                                                                             |
+| `uipath.json`    | Input/output json schemas and bindings.                                                                                           |
+| `langgraph.json` | [LangGraph](https://langchain-ai.github.io/langgraph/concepts/application_structure/#file-structure) specific configuration file. |
+| `agent.mermaid`  | Graph visual representation.                                                                                                      |
+
+## Set Up Environment Variables
+
+Before running the agent, set either `ANTHROPIC_API_KEY` or `OPENAI_API_KEY` in the previously created `.env` file:
+
+```
+ANTHROPIC_API_KEY=your_api_key_here
+```
+or
+```
+OPENAI_API_KEY=your_api_key_here
+```
+
+## Run the Agent Locally
+
+Execute the agent with a sample input:
+
+```bash
+uipath run agent '{"topic": "UiPath"}'
+```
+
+This command runs your agent locally and generates the report at standard output.
+
+## Pack and Publish the agent on UiPath Cloud Platform
+
+Follow these steps to publish and run your agent on UiPath Cloud Platform:
+
+### Authenticate with UiPath
+```bash
+uipath auth
+```
+
+### (Optional) Update author details in `pyproject.toml`
+```toml
+authors = [{ name = "John Doe", email = "john.doe@example.com" }]
+```
+
+### Package your project:
+```bash
+uipath pack
+```
+
+### Publish to your workspace
+```bash
+uipath publish --my-workspace
+```
+> Please note that a process will be auto-created only upon publishing to **my-workspace** package feed.
+
+### Configure environment variables using the provided link
+
+![Set Environment Variables](quick_start_images/cloud_env_var.png)
+
+## Invoke the Agent on UiPath Platform
+
+Invoke the agent in UiPath Cloud Platform:
+
+```bash
+uipath invoke agent '{"topic": "UiPath"}'
+```
+
+**Expected output:**
+```
+⠦ Loading configuration ...
+⠦ Starting job ...
+✨ Job started successfully!
+🔗 Monitor your job here: https://example.com
+```
+
+Use the provided link to monitor your job and view detailed traces.
+
+## Next steps
+
+Congratulations! You have successfully set up, created, published, and run a UiPath LangChain Agent. 🚀
+
+For more advanced agents and examples, please refer to our [samples section](../samples).

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

@@ -1,11 +1,11 @@
 [project]
 name = "uipath-langchain"
-version = "0.0.99"
+version = "0.0.101"
 description = "UiPath Langchain"
 readme = { file = "README.md", content-type = "text/markdown" }
 requires-python = ">=3.10"
 dependencies = [
-    "uipath>=2.0.28, <2.1.0",
+    "uipath>=2.0.31, <2.1.0",
     "langgraph>=0.2.70",
     "langchain-core>=0.3.34",
     "langgraph-checkpoint-sqlite>=2.0.3",

uipath_langchain-0.0.101/samples/README.md

@@ -0,0 +1,19 @@
+# Project Samples
+
+## [Multi agent supervisor, researcher, coder](multi-agent-supervisor-researcher-coder)
+This sample showcases a multi-agent system, involving a supervisor, a researcher, and a coder working in coordination to tackle complex tasks.
+
+## [Multi agent planner, researcher, coder distributed](multi-agent-planner-researcher-coder-distributed)
+Here, a multi-agent system breaks down complex tasks into discreet steps, routing them to specialized agents. Each agent operates **independently** and can be deployed as a separate process. The system includes a planner, researcher, and coder agent.
+
+## [Retrieval chain](retrieval-chain)
+This example shows how to retrieve relevant documents for a query, using the UiPath Context Grounding vectorstore. It also integrates this into a Langchain retrieval chain for response formulation.
+
+## [Simple local MCP](simple-local-mcp)
+This sample shows how to create an agent using LangGraph with multiple tool servers via the MCP (Model Context Protocol) standard.
+
+## [Simple remote MCP](simple-remote-mcp)
+This sample demonstrates the creation of an agent using LangGraph, which connects to a remote MCP (Model Context Protocol) Server.
+
+## [Ticket classification](ticket-classification)
+This sample demonstrates automatic classification of support tickets into categories. It includes a human approval step via UiPath Action Center.

{uipath_langchain-0.0.99 → uipath_langchain-0.0.101}/samples/company-research-agent/pyproject.toml

@@ -1,17 +1,14 @@
 [project]
 name = "company-research-agent"
-version = "0.0.2"
+version = "0.0.1"
 description = "Company research agent with Tavily web search"
-authors = [
-    { name = "John Doe" }
-]
+authors = [{ name = "John Doe", email = "john.doe@myemail.com" }]
 requires-python = ">=3.10"
 dependencies = [
     "langgraph>=0.2.55",
-    "langchain-community>=0.3.9",
     "langchain-anthropic>=0.3.8",
     "tavily-python>=0.5.0",
-    "uipath-langchain==0.0.88"
+    "uipath-langchain==0.0.100"
 ]
 
 [project.optional-dependencies]

{uipath_langchain-0.0.99 → uipath_langchain-0.0.101}/samples/hitl-inbox-server/pyproject.toml

@@ -2,7 +2,7 @@
 name = "hitl-inbox-server"
 version = "0.0.1"
 description = "HITL Inbox"
-authors = [{ name = "Cristi Pufu", email = "cristian.pufu@uipath.com" }]
+authors = [{ name = "John Doe", email = "john.doe@myemail.com" }]
 dependencies = [
     "fastapi>=0.115.11",
     "uvicorn>=0.34.0",
@@ -11,6 +11,6 @@ dependencies = [
     "jinja2>=3.1.6",
     "httpx>=0.28.1",
     "python-multipart>=0.0.20",
-    "uipath==2.0.4"
+    "uipath==2.0.31"
 ]
 requires-python = ">=3.10"

{uipath_langchain-0.0.99 → uipath_langchain-0.0.101}/samples/multi-agent-planner-researcher-coder-distributed/README.md

@@ -6,7 +6,7 @@ This repository implements a multi-agent system that decomposes complex tasks in
 2. **Researcher Agent**: Gathers information, formulas, and reference materials without performing calculations.
 3. **Coder Agent**: Executes calculations and evaluates formulas with specific values.
 
-Each agent operates as an independent entry point and can be deployed as a separate process, while still being packaged together as part of an Orchestrator Agent Package.
+Each agent operates independently and can be deployed as a separate process, while still being packaged together as part of an Orchestrator Agent Package.
 
 ## System Architecture
 
@@ -178,33 +178,31 @@ uipath run coder '{"messages":[{"content":"Let me help you state the Pythagorean
    uipath auth
    ```
    > **Note:** After successful authentication in the browser, select the tenant for publishing the agent package.
-   ```
-   Received log data
-   Received authentication information
-   Available tenants:
-     0: cosmin
-     1: DefaultTenant
-     2: Demo
-     3: lucian
-     4: Solutions
-     5: SolutionsTest
-     6: Test
-     7: TestRoles
-   Select tenant: 2
-   ```
+```
+👇 Select tenant:
+  0: DefaultTenant
+  1: Tenant2
+  2: Tenant3
+...
+Select tenant: 2
+```
 
 5. **Package and Publish Agents**
    ```bash
    uipath pack
    uipath publish
    ```
-   > **Note:** You will need to select the feed for publishing:
-   ```
-   Select feed type:
-     0: Tenant package feed
-     1: Personal workspace
-   Select feed: 0
-   ```
+Select the feed to publish your package:
+```
+👇 Select package feed:
+  0: Orchestrator Tenant Processes Feed
+  1: Orchestrator Folder1 Feed
+  2: Orchestrator Folder2 Feed
+  3: Orchestrator Personal Workspace Feed
+  ...
+Select feed number: 3
+```
+> Note: When publishing to personal workspace feed, a process will be auto-created for you.
 
 6. **Create Agent Processes in Orchestrator**
    - **Planner Agent**

{uipath_langchain-0.0.99 → uipath_langchain-0.0.101}/samples/multi-agent-planner-researcher-coder-distributed/pyproject.toml

@@ -2,17 +2,14 @@
 name = "multi-agents-distributed"
 version = "0.0.1"
 description = "Supervisor agent that coordinates between a researcher and a coder"
-authors = [
-    { name = "Radu Mocanu", email = "radu.mocanu@uipath.com" }
-]
+authors = [[{ name = "John Doe", email = "john.doe@myemail.com" }]]
 requires-python = ">=3.10"
 dependencies = [
     "langgraph>=0.2.55",
-    "langchain-community>=0.3.9",
     "langchain-anthropic>=0.3.8",
     "langchain-experimental>=0.3.4",
     "tavily-python>=0.5.0",
-    "uipath-langchain==0.0.90"
+    "uipath-langchain==0.0.100"
 ]
 
 [project.optional-dependencies]

{uipath_langchain-0.0.99 → uipath_langchain-0.0.101}/samples/multi-agent-supervisor-researcher-coder/pyproject.toml

@@ -1,18 +1,15 @@
 [project]
 name = "multi_agent_supervisor"
-version = "0.0.9"
+version = "0.0.1"
 description = "Multi-agent system where a supervisor coordinates between a researcher and a coder"
-authors = [
-    { name = "Cristi Pufu" }
-]
+authors = [[{ name = "John Doe", email = "john.doe@myemail.com" }]]
 requires-python = ">=3.10"
 dependencies = [
     "langgraph>=0.2.55",
-    "langchain-community>=0.3.9",
     "langchain-anthropic>=0.3.8",
     "langchain-experimental>=0.3.4",
     "tavily-python>=0.5.0",
-    "uipath-langchain==0.0.88"
+    "uipath-langchain==0.0.100"
 ]
 
 [project.optional-dependencies]

{uipath_langchain-0.0.99 → uipath_langchain-0.0.101}/samples/retrieval-chain/pyproject.toml

@@ -2,8 +2,8 @@
 name = "retrieval-chain"
 version = "0.0.1"
 description = "Sample retrieval chain using UiPath Context Grounding API"
-authors = [{ name = "Andrei Rusu", email = "andrei.rusu@uipath.com" }]
+authors = [{ name = "John Doe", email = "john.doe@myemail.com" }]s
 dependencies = [
-    "uipath-langchain==0.0.88",
+    "uipath-langchain==0.0.100",
 ]
 requires-python = ">=3.10"

{uipath_langchain-0.0.99 → uipath_langchain-0.0.101}/samples/simple-local-mcp/pyproject.toml

@@ -1,15 +1,15 @@
 [project]
 name = "simple-local-mcp"
-version = "0.0.3"
+version = "0.0.1"
 description = "Math and Weather Local MCP Server Agent"
-authors = [{ name = "Cristi Pufu", email = "cristian.pufu@uipath.com" }]
+authors = [{ name = "John Doe", email = "john.doe@myemail.com" }]
 dependencies = [
     "langgraph>=0.2.70",
     "langchain-core>=0.3.34",
     "langchain-anthropic>=0.3.9",
     "langgraph-checkpoint-sqlite>=2.0.3",
     "python-dotenv>=1.0.1",
-    "uipath-langchain==0.0.88",
+    "uipath-langchain==0.0.100",
     "pydantic>=2.10.6",
     "aiohttp>=3.11.12",
     "typing-extensions>=4.12.2",

{uipath_langchain-0.0.99 → uipath_langchain-0.0.101}/samples/simple-remote-mcp/pyproject.toml

@@ -4,7 +4,7 @@ version = "0.0.1"
 description = "simple-remote-mcp"
 authors = [{ name = "John Doe", email = "john.doe@myemail.com" }]
 dependencies = [
-    "uipath-langchain==0.0.88",
+    "uipath-langchain==0.0.100",
     "langchain>=0.1.0",
     "langchain-anthropic>=0.0.1",
     "langgraph>=0.3.21",