uipath-langchain 0.0.93__tar.gz → 0.0.95__tar.gz

{uipath_langchain-0.0.93 → uipath_langchain-0.0.95}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: uipath-langchain
-Version: 0.0.93
+Version: 0.0.95
 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.14
+Requires-Dist: uipath<2.1.0,>=2.0.23
 Provides-Extra: langchain
 Description-Content-Type: text/markdown
 

{uipath_langchain-0.0.93 → uipath_langchain-0.0.95}/docs/chat_models.md

@@ -81,7 +81,7 @@ llm = UiPathNormalizedChatModel(
 )
 ```
 
-Currently the following models can be used with `UiPathAzureChatOpenAI` (this list can be updated in the future): 
+Currently the following models can be used with `UiPathNormalizedChatModel` (this list can be updated in the future): 
 - `anthropic.claude-3-5-sonnet-20240620-v1:0`, `anthropic.claude-3-5-sonnet-20241022-v2:0`, `anthropic.claude-3-7-sonnet-20250219-v1:0`, `anthropic.claude-3-haiku-20240307-v1:0`, `gemini-1.5-pro-001`, `gemini-2.0-flash-001`, `gpt-4o-2024-05-13`, `gpt-4o-2024-08-06`, `gpt-4o-2024-11-20`, `gpt-4o-mini-2024-07-18`, `o3-mini-2025-01-31`
 
 ### Note 

{uipath_langchain-0.0.93 → uipath_langchain-0.0.95}/docs/context_grounding_retriever.md

@@ -1,4 +1,4 @@
-# Context Grounding Retriever
+# ContextGroundingRetriever
 
 The `ContextGroundingRetriever` is a document retrieval system that uses vector search to efficiently find and retrieve relevant information from your document store.
 
@@ -10,6 +10,8 @@ The `ContextGroundingRetriever` is a document retrieval system that uses vector
 - Retrieve context-relevant documents for various applications
 
 
+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.
+
 ## Basic Usage
 
 Create a simple retriever by specifying an index name:
@@ -18,7 +20,7 @@ Create a simple retriever by specifying an index name:
 from uipath_langchain.retrievers import ContextGroundingRetriever
 
 retriever = ContextGroundingRetriever(index_name = "Company Policy Context")
-pprint(retriever.invoke("What is the company policy on remote work?"))
+print(retriever.invoke("What is the company policy on remote work?"))
 ```
 
 ## Integration with LangChain Tools
@@ -26,6 +28,7 @@ pprint(retriever.invoke("What is the company policy on remote work?"))
 You can easily integrate the retriever with LangChain's tool system:
 
 ```python
+from langchain.agents import create_react_agent
 from langchain.tools.retriever import create_retriever_tool
 from uipath_langchain.retrievers import ContextGroundingRetriever
 
@@ -38,6 +41,11 @@ retriever_tool = create_retriever_tool(
    Use a meaningful query to load relevant information from the documents. Save the citation for later use.
    """
 )
+
+# You can use the tool in your agents
+model = OpenAI()
+tools = [retriever_tool]
+agent = create_react_agent(model, tools, prompt="Answer user questions as best as you can using the search tool.")
 ```
 
 

uipath_langchain-0.0.95/docs/context_grounding_vector_store.md

@@ -0,0 +1,35 @@
+# 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.
+
+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.
+
+
+## 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.93 → uipath_langchain-0.0.95}/pyproject.toml

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

uipath_langchain-0.0.95/src/uipath_langchain/_cli/_templates/langgraph.json.template

@@ -0,0 +1,7 @@
+{
+    "dependencies": ["."],
+    "graphs": {
+      "agent": "./main.py:graph"
+    },
+    "env": ".env"
+  }

uipath_langchain-0.0.95/src/uipath_langchain/_cli/_templates/main.py.template

@@ -0,0 +1,33 @@
+from langchain_anthropic import ChatAnthropic
+from langchain_core.messages import HumanMessage, SystemMessage
+from langchain_openai import ChatOpenAI
+from langgraph.graph import START, StateGraph, END
+from pydantic import BaseModel
+import os
+
+class GraphInput(BaseModel):
+    topic: str
+
+class GraphOutput(BaseModel):
+    report: str
+
+async def generate_report(state: GraphInput) -> GraphOutput:
+    if os.getenv("ANTHROPIC_API_KEY"):
+        llm_model = ChatAnthropic(model="claude-3-5-sonnet-latest")
+    elif os.getenv("OPENAI_API_KEY"):
+        llm_model = ChatOpenAI(model="gpt-4o-mini", temperature=0)
+    else:
+        raise Exception("Error: Missing API Key. Please define either ANTHROPIC_API_KEY or OPENAI_API_KEY.")
+
+    system_prompt = "You are a report generator. Please provide a brief report based on the given topic."
+    output = await llm_model.ainvoke([SystemMessage(system_prompt), HumanMessage(state.topic)])
+    return GraphOutput(report=output.content)
+
+builder = StateGraph(input=GraphInput, output=GraphOutput)
+
+builder.add_node("generate_report", generate_report)
+
+builder.add_edge(START, "generate_report")
+builder.add_edge("generate_report", END)
+
+graph = builder.compile()

{uipath_langchain-0.0.93 → uipath_langchain-0.0.95}/src/uipath_langchain/_cli/cli_init.py

@@ -4,9 +4,11 @@ import os
 import uuid
 from typing import Any, Dict
 
+import click
 from langgraph.graph.state import CompiledStateGraph
 from uipath._cli._utils._parse_ast import generate_bindings_json  # type: ignore
 from uipath._cli.middlewares import MiddlewareResult
+from uipath._cli.spinner import Spinner
 
 from ._utils._graph import LangGraphConfig
 
@@ -32,6 +34,25 @@ def resolve_refs(schema, root=None):
     return schema
 
 
+def process_nullable_types(
+    schema: Dict[str, Any] | list[Any] | Any,
+) -> Dict[str, Any] | list[Any]:
+    """Process the schema to handle nullable types by removing anyOf with null and keeping the base type."""
+    if isinstance(schema, dict):
+        if "anyOf" in schema and len(schema["anyOf"]) == 2:
+            types = [t.get("type") for t in schema["anyOf"]]
+            if "null" in types:
+                non_null_type = next(
+                    t for t in schema["anyOf"] if t.get("type") != "null"
+                )
+                return non_null_type
+
+        return {k: process_nullable_types(v) for k, v in schema.items()}
+    elif isinstance(schema, list):
+        return [process_nullable_types(item) for item in schema]
+    return schema
+
+
 def generate_schema_from_graph(graph: CompiledStateGraph) -> Dict[str, Any]:
     """Extract input/output schema from a LangGraph graph"""
     schema = {
@@ -42,12 +63,14 @@ def generate_schema_from_graph(graph: CompiledStateGraph) -> Dict[str, Any]:
     if hasattr(graph, "input_schema"):
         if hasattr(graph.input_schema, "model_json_schema"):
             input_schema = graph.input_schema.model_json_schema()
-
             unpacked_ref_def_properties = resolve_refs(input_schema)
 
-            schema["input"]["properties"] = unpacked_ref_def_properties.get(
-                "properties", {}
+            # Process the schema to handle nullable types
+            processed_properties = process_nullable_types(
+                unpacked_ref_def_properties.get("properties", {})
             )
+
+            schema["input"]["properties"] = processed_properties
             schema["input"]["required"] = unpacked_ref_def_properties.get(
                 "required", []
             )
@@ -55,11 +78,14 @@ def generate_schema_from_graph(graph: CompiledStateGraph) -> Dict[str, Any]:
     if hasattr(graph, "output_schema"):
         if hasattr(graph.output_schema, "model_json_schema"):
             output_schema = graph.output_schema.model_json_schema()
-
             unpacked_ref_def_properties = resolve_refs(output_schema)
-            schema["output"]["properties"] = unpacked_ref_def_properties.get(
-                "properties", {}
+
+            # Process the schema to handle nullable types
+            processed_properties = process_nullable_types(
+                unpacked_ref_def_properties.get("properties", {})
             )
+
+            schema["output"]["properties"] = processed_properties
             schema["output"]["required"] = unpacked_ref_def_properties.get(
                 "required", []
             )
@@ -69,6 +95,7 @@ def generate_schema_from_graph(graph: CompiledStateGraph) -> Dict[str, Any]:
 
 async def langgraph_init_middleware_async(entrypoint: str) -> MiddlewareResult:
     """Middleware to check for langgraph.json and create uipath.json with schemas"""
+    spinner = Spinner("Initializing UiPath project...")
     config = LangGraphConfig()
     if not config.exists:
         return MiddlewareResult(
@@ -76,6 +103,7 @@ async def langgraph_init_middleware_async(entrypoint: str) -> MiddlewareResult:
         )  # Continue with normal flow if no langgraph.json
 
     try:
+        spinner.start()
         config.load_config()
         entrypoints = []
         all_bindings = {"version": "2.0", "resources": []}
@@ -98,7 +126,6 @@ async def langgraph_init_middleware_async(entrypoint: str) -> MiddlewareResult:
                 mermaids[graph.name] = compiled_graph.get_graph(xray=1).draw_mermaid()
 
                 try:
-                    print("Generating bindings for ", graph.file_path)
                     # Make sure the file path exists
                     if os.path.exists(graph.file_path):
                         file_bindings = generate_bindings_json(graph.file_path)
@@ -108,7 +135,7 @@ async def langgraph_init_middleware_async(entrypoint: str) -> MiddlewareResult:
                             all_bindings["resources"] = file_bindings["resources"]
                 except Exception as e:
                     print(
-                        f"Warning: Could not generate bindings for {graph.file_path}: {str(e)}"
+                        f"⚠️ Warning: Could not generate bindings for {graph.file_path}: {str(e)}"
                     )
 
                 new_entrypoint: dict[str, Any] = {
@@ -121,19 +148,21 @@ async def langgraph_init_middleware_async(entrypoint: str) -> MiddlewareResult:
                 entrypoints.append(new_entrypoint)
 
             except Exception as e:
+                spinner.stop()
                 print(f"Error during graph load: {e}")
                 return MiddlewareResult(
                     should_continue=False,
-                    error_message=f"Failed to load graph '{graph.name}': {str(e)}",
+                    error_message=f"❌ Failed to load graph '{graph.name}': {str(e)}",
                     should_include_stacktrace=True,
                 )
             finally:
                 await graph.cleanup()
 
         if entrypoint and not entrypoints:
+            spinner.stop()
             return MiddlewareResult(
                 should_continue=False,
-                error_message=f"Error: No graph found with name '{entrypoint}'",
+                error_message=f"❌ Error: No graph found with name '{entrypoint}'",
             )
 
         uipath_config = {"entryPoints": entrypoints, "bindings": all_bindings}
@@ -149,21 +178,24 @@ async def langgraph_init_middleware_async(entrypoint: str) -> MiddlewareResult:
                 with open(mermaid_file_path, "w") as f:
                     f.write(mermaid_content)
             except Exception as write_error:
+                spinner.stop()
                 return MiddlewareResult(
                     should_continue=False,
-                    error_message=f"Error writing mermaid file for '{graph_name}': {str(write_error)}",
+                    error_message=f"❌ Error writing mermaid file for '{graph_name}': {str(write_error)}",
                     should_include_stacktrace=True,
                 )
-
+        spinner.stop()
         return MiddlewareResult(
             should_continue=False,
-            info_message=f"Configuration file {config_path} created successfully.",
+            info_message=click.style("✓ ", fg="green", bold=True)
+            + f" Configuration file {config_path} created successfully.",
         )
 
     except Exception as e:
+        spinner.stop()
         return MiddlewareResult(
             should_continue=False,
-            error_message=f"Error processing langgraph configuration: {str(e)}",
+            error_message=f"❌ Error processing langgraph configuration: {str(e)}",
             should_include_stacktrace=True,
         )
 

uipath_langchain-0.0.95/src/uipath_langchain/_cli/cli_new.py

@@ -0,0 +1,76 @@
+import os
+import shutil
+
+import click
+from uipath._cli.middlewares import MiddlewareResult
+from uipath._cli.spinner import Spinner
+
+
+def generate_script(target_directory):
+    template_script_path = os.path.join(
+        os.path.dirname(__file__), "_templates/main.py.template"
+    )
+    target_path = os.path.join(target_directory, "main.py")
+
+    shutil.copyfile(template_script_path, target_path)
+
+    template_langgraph_json_path = os.path.join(
+        os.path.dirname(__file__), "_templates/langgraph.json.template"
+    )
+    target_path = os.path.join(target_directory, "langgraph.json")
+    shutil.copyfile(template_langgraph_json_path, target_path)
+
+
+def generate_pyproject(target_directory, project_name):
+    project_toml_path = os.path.join(target_directory, "pyproject.toml")
+    toml_content = f"""[project]
+                        name = "{project_name}"
+                        version = "0.0.1"
+                        description = "{project_name}"
+                        authors = [{{ name = "John Doe", email = "john.doe@myemail.com" }}]
+                        dependencies = [
+                            "uipath-langchain>=0.0.95",
+                            "langchain-anthropic>=0.3.8",
+                        ]
+                        requires-python = ">=3.10"
+                    """
+
+    with open(project_toml_path, "w") as f:
+        f.write(toml_content)
+
+
+def langgraph_new_middleware(name: str) -> MiddlewareResult:
+    """Middleware to create demo langchain agent"""
+    spinner = Spinner("Creating demo agent...")
+    directory = os.getcwd()
+
+    try:
+        generate_script(directory)
+        click.echo(click.style("✓ ", fg="green", bold=True) + "Created main.py file")
+        click.echo(
+            click.style("✓ ", fg="green", bold=True) + "Created langgraph.json file"
+        )
+        generate_pyproject(directory, name)
+        click.echo(
+            click.style("✓ ", fg="green", bold=True) + "Created pyproject.toml file"
+        )
+        os.system("uv sync")
+        spinner.start()
+        ctx = click.get_current_context()
+        init_cmd = ctx.parent.command.get_command(ctx, "init")  # type: ignore
+        ctx.invoke(init_cmd)
+        spinner.stop()
+        click.echo(
+            click.style("✓ ", fg="green", bold=True) + " Agent created successfully."
+        )
+        return MiddlewareResult(
+            should_continue=False,
+            info_message="""Usage example: ` uipath run agent '{"topic": "UiPath"}' `""",
+        )
+    except Exception as e:
+        spinner.stop()
+        return MiddlewareResult(
+            should_continue=False,
+            error_message=f"❌ Error creating demo agent {str(e)}",
+            should_include_stacktrace=True,
+        )

{uipath_langchain-0.0.93 → uipath_langchain-0.0.95}/src/uipath_langchain/middlewares.py

@@ -1,6 +1,7 @@
 from uipath._cli.middlewares import Middlewares
 
 from ._cli.cli_init import langgraph_init_middleware
+from ._cli.cli_new import langgraph_new_middleware
 from ._cli.cli_run import langgraph_run_middleware
 
 
@@ -8,3 +9,4 @@ def register_middleware():
     """This function will be called by the entry point system when uipath_langchain is installed"""
     Middlewares.register("init", langgraph_init_middleware)
     Middlewares.register("run", langgraph_run_middleware)
+    Middlewares.register("new", langgraph_new_middleware)