LangGraph Utilities

Warnings

• gotcha The official PyPI description for `langgraph-utils` (version 0.0.7.4) specifies its role as a 'LangChain Tools JSON Converter', focusing on `create_tools_json`. This is more specific than the broader 'Utilities for Langchain and langgraph' summary provided in some contexts. Ensure this specific JSON conversion functionality aligns with your needs.
  Fix: Refer to the official PyPI page for `langgraph-utils` for the precise functionality and exposed methods.
• breaking LangChain and LangGraph APIs, including tool definitions (`StructuredTool`), undergo updates. Breaking changes, especially in major LangChain/LangGraph versions (e.g., LangGraph v1.0), could affect how tools are defined or interpreted, potentially impacting the serialization/deserialization process.
  Fix: Always pin major versions of `langchain` and `langgraph`. Regularly check their migration guides (e.g., LangGraph v1 migration guide) and test your serialization/deserialization logic when upgrading core LangChain/LangGraph libraries.
• gotcha If `langgraph-utils` is used within a larger LangGraph application, pay close attention to state management. Incorrectly serialized or deserialized tool definitions, or state changes during parallel execution, can lead to unexpected tool calls or graph behavior.
  Fix: Define a clear `TypedDict` or Pydantic model for your graph state. Validate tool inputs and outputs rigorously within your nodes. Utilize LangGraph's checkpointing and LangSmith for debugging complex state transitions.

Install

• pip install langgraph-utils==0.0.7.4 Install specific version
• pip install langgraph-utils Install latest version

Imports

• create_tools_json

  from langgraph_utils import create_tools_json

  This function converts a list of LangChain StructuredTool objects into a JSON string.

Quickstart

This quickstart demonstrates how to use `create_tools_json` to serialize a list of mock LangChain `StructuredTool` objects into a JSON string. While the `langgraph-utils` PyPI description mentions conversion 'and vice versa', the `create_tools_json` function is explicitly detailed. For deserialization, you would typically use standard JSON parsing and potentially recreate `StructuredTool` instances based on the JSON structure.

import os
from typing import List, Dict, Any
from langchain_core.tools import StructuredTool
from langgraph_utils import create_tools_json

# Mock a LangChain StructuredTool
# In a real application, you would import and define actual tools.
class MockTool(StructuredTool):
    name: str = "mock_tool"
    description: str = "A mock tool for demonstration."
    args_schema: Dict[str, Any] = {"param": {"type": "string", "description": "A parameter"}}
    
    def _run(self, param: str) -> str:
        return f"MockTool executed with: {param}"

    async def _arun(self, param: str) -> str:
        return f"MockTool async executed with: {param}"


mock_tools = [
    MockTool(name='search_internet', description='Searches the internet for information'),
    MockTool(name='get_weather', description='Fetches current weather for a location')
]

tools_json_string = create_tools_json(mock_tools)
print(f"Serialized Tools: {tools_json_string}")

# Example of deserialization (assuming a hypothetical deserialize_tools_json function exists or custom logic)
# This library's PyPI description focuses on 'create_tools_json', but also mentions 'and vice versa'.
# For full deserialization, you might need to implement custom logic or use other LangChain utilities.
# For illustrative purposes, we'll just show the structure.
import json
deserialized_data = json.loads(tools_json_string)
print(f"Deserialized data structure: {deserialized_data[0]['name']}")