Add langchain tool support (#8292)

* add langchain tool support

* rename

* update dependencies

Author: TomeHirata

docs/docs/api/primitives/Tool.md

@@ -8,6 +8,7 @@
             - __call__
             - acall
             - from_mcp_tool
+            - from_langchain
         show_source: true
         show_root_heading: true
         heading_level: 2

docs/requirements.txt

@@ -1,4 +1,4 @@
-git+https://github.com/stanfordnlp/dspy.git
+-e ..
 mkdocs-material
 mkdocs-jupyter
 mkdocs-material[imaging]

dspy/predict/react.py

@@ -16,7 +16,7 @@ def __init__(self, signature, tools: list[Callable], max_iters=5):
         """
         `tools` is either a list of functions, callable classes, or `dspy.Tool` instances.
         """
-
+        super().__init__()
         self.signature = signature = ensure_signature(signature)
         self.max_iters = max_iters
 

dspy/primitives/tool.py

@@ -1,6 +1,6 @@
 import asyncio
 import inspect
-from typing import TYPE_CHECKING, Any, Callable, Optional, get_origin, get_type_hints
+from typing import TYPE_CHECKING, Any, Callable, Optional, Tuple, Type, get_origin, get_type_hints
 
 from jsonschema import ValidationError, validate
 from pydantic import BaseModel, TypeAdapter, create_model
@@ -9,7 +9,9 @@
 
 if TYPE_CHECKING:
     import mcp
+    from langchain.tools import BaseTool
 
+_TYPE_MAPPING = {"string": str, "integer": int, "number": float, "boolean": bool, "array": list, "object": dict}
 
 class Tool:
     """Tool class.
@@ -94,7 +96,7 @@ def _parse_function(self, func: Callable, arg_desc: Optional[dict[str, str]] = N
             origin = get_origin(v) or v
             if isinstance(origin, type) and issubclass(origin, BaseModel):
                 # Get json schema, and replace $ref with the actual schema
-                v_json_schema = resolve_json_schema_reference(v.model_json_schema())
+                v_json_schema = _resolve_json_schema_reference(v.model_json_schema())
                 args[k] = v_json_schema
             else:
                 args[k] = TypeAdapter(v).json_schema()
@@ -172,6 +174,21 @@ def from_mcp_tool(cls, session: "mcp.client.session.ClientSession", tool: "mcp.t
 
         return convert_mcp_tool(session, tool)
 
+    @classmethod
+    def from_langchain(cls, tool: "BaseTool") -> "Tool":
+        """
+        Build a DSPy tool from a LangChain tool.
+
+        Args:
+            tool: The LangChain tool to convert.
+
+        Returns:
+            A Tool object.
+        """
+        from dspy.utils.langchain_tool import convert_langchain_tool
+
+        return convert_langchain_tool(tool)
+    
     def __repr__(self):
         return f"Tool(name={self.name}, desc={self.desc}, args={self.args})"
 
@@ -181,7 +198,7 @@ def __str__(self):
         return f"{self.name}{desc} {arg_desc}"
 
 
-def resolve_json_schema_reference(schema: dict) -> dict:
+def _resolve_json_schema_reference(schema: dict) -> dict:
     """Recursively resolve json model schema, expanding all references."""
 
     # If there are no definitions to resolve, return the main schema
@@ -205,3 +222,35 @@ def resolve_refs(obj: Any) -> Any:
     # Remove the $defs key as it's no longer needed
     resolved_schema.pop("$defs", None)
     return resolved_schema
+
+
+def convert_input_schema_to_tool_args(
+    schema: dict[str, Any],
+) -> Tuple[dict[str, Any], dict[str, Type], dict[str, str]]:
+    """Convert an input json schema to tool arguments compatible with DSPy Tool.
+
+    Args:
+        schema: An input json schema describing the tool's input parameters
+
+    Returns:
+        A tuple of (args, arg_types, arg_desc) for DSPy Tool definition.
+    """
+    args, arg_types, arg_desc = {}, {}, {}
+    properties = schema.get("properties", None)
+    if properties is None:
+        return args, arg_types, arg_desc
+
+    required = schema.get("required", [])
+
+    defs = schema.get("$defs", {})
+
+    for name, prop in properties.items():
+        if len(defs) > 0:
+            prop = _resolve_json_schema_reference({"$defs": defs, **prop})
+        args[name] = prop
+        arg_types[name] = _TYPE_MAPPING.get(prop.get("type"), Any)
+        arg_desc[name] = prop.get("description", "No description provided.")
+        if name in required:
+            arg_desc[name] += " (Required)"
+
+    return args, arg_types, arg_desc

dspy/utils/langchain_tool.py

@@ -0,0 +1,46 @@
+from typing import TYPE_CHECKING, Any
+from dspy.primitives.tool import Tool, convert_input_schema_to_tool_args
+
+if TYPE_CHECKING:
+    from langchain.tools import BaseTool
+
+
+
+def convert_langchain_tool(tool: "BaseTool") -> Tool:
+    """Build a DSPy tool from a LangChain tool.
+    
+    This function converts a LangChain tool (either created with @tool decorator
+    or by subclassing BaseTool) into a DSPy Tool.
+
+    Args:
+        tool: The LangChain tool to convert.
+
+    Returns:
+        A DSPy Tool object.
+    """
+    async def func(**kwargs):
+        try:
+            result = await tool.ainvoke(kwargs)
+            return result
+        except Exception as e:
+            raise RuntimeError(f"Failed to call LangChain tool {tool.name}: {str(e)}")
+    
+    # Get args_schema from the tool
+    # https://python.langchain.com/api_reference/core/tools/langchain_core.tools.base.BaseTool.html#langchain_core.tools.base.BaseTool.args_schema
+    args_schema = tool.args_schema
+    args, _, arg_desc = convert_input_schema_to_tool_args(args_schema.model_json_schema())
+    
+    # The args_schema of Langchain tool is a pydantic model, so we can get the type hints from the model fields
+    arg_types = {
+        key: field.annotation if field.annotation is not None else Any
+        for key, field in args_schema.model_fields.items()
+    }
+
+    return Tool(
+        func=func,
+        name=tool.name,
+        desc=tool.description,
+        args=args,
+        arg_types=arg_types,
+        arg_desc=arg_desc
+    ) 

dspy/utils/mcp.py

@@ -1,45 +1,10 @@
-from typing import TYPE_CHECKING, Any, Tuple, Type, Union
+from typing import TYPE_CHECKING, Any, Union
 
-from dspy.primitives.tool import Tool, resolve_json_schema_reference
+from dspy.primitives.tool import Tool, convert_input_schema_to_tool_args
 
 if TYPE_CHECKING:
     import mcp
 
-TYPE_MAPPING = {"string": str, "integer": int, "number": float, "boolean": bool, "array": list, "object": dict}
-
-
-def _convert_input_schema_to_tool_args(
-    schema: dict[str, Any],
-) -> Tuple[dict[str, Any], dict[str, Type], dict[str, str]]:
-    """Convert an input schema to tool arguments compatible with DSPy Tool.
-
-    Args:
-        schema: An input schema describing the tool's input parameters
-
-    Returns:
-        A tuple of (args, arg_types, arg_desc) for DSPy Tool definition.
-    """
-    args, arg_types, arg_desc = {}, {}, {}
-    properties = schema.get("properties", None)
-    if properties is None:
-        return args, arg_types, arg_desc
-
-    required = schema.get("required", [])
-
-    defs = schema.get("$defs", {})
-
-    for name, prop in properties.items():
-        if len(defs) > 0:
-            prop = resolve_json_schema_reference({"$defs": defs, **prop})
-        args[name] = prop
-        # MCP tools are validated through jsonschema using args, so arg_types are not strictly required.
-        arg_types[name] = TYPE_MAPPING.get(prop.get("type"), Any)
-        arg_desc[name] = prop.get("description", "No description provided.")
-        if name in required:
-            arg_desc[name] += " (Required)"
-
-    return args, arg_types, arg_desc
-
 
 def _convert_mcp_tool_result(call_tool_result: "mcp.types.CallToolResult") -> Union[str, list[Any]]:
     from mcp.types import TextContent
@@ -72,7 +37,7 @@ def convert_mcp_tool(session: "mcp.client.session.ClientSession", tool: "mcp.typ
     Returns:
         A dspy Tool object.
     """
-    args, arg_types, arg_desc = _convert_input_schema_to_tool_args(tool.inputSchema)
+    args, arg_types, arg_desc = convert_input_schema_to_tool_args(tool.inputSchema)
 
     # Convert the MCP tool and Session to a single async method
     async def func(*args, **kwargs):

pyproject.toml

@@ -52,6 +52,7 @@ anthropic = ["anthropic>=0.18.0,<1.0.0"]
 weaviate = ["weaviate-client~=4.5.4"]
 aws = ["boto3~=1.34.78"]
 mcp = ["mcp; python_version >= '3.10'"]
+langchain = ["langchain_core"]
 dev = [
     "pytest>=6.2.5",
     "pytest-mock>=3.12.0",
@@ -66,6 +67,7 @@ dev = [
 ]
 test_extras = [
     "mcp; python_version >= '3.10'",
+    "langchain_core",
 ]
 
 [tool.setuptools.packages.find]

tests/utils/test_langchain_tool.py

@@ -0,0 +1,51 @@
+import importlib
+import pytest
+
+if importlib.util.find_spec("langchain_core") is None:
+    pytest.skip(reason="langchain_core is not installed", allow_module_level=True)
+
+from pydantic import BaseModel
+
+from dspy.utils.langchain_tool import convert_langchain_tool
+
+
+@pytest.mark.asyncio
+@pytest.mark.extra
+async def test_convert_custom_simple_tool():
+    from langchain_core.tools import tool
+
+    @tool
+    def add(a: int, b: int) -> int:
+        """Add two numbers."""
+        return a + b
+
+    tool = convert_langchain_tool(add)
+    assert tool.name == "add"
+    assert tool.desc == "Add two numbers."
+    assert tool.args == {"a": {"title": "A", "type": "integer"}, "b": {"title": "B", "type": "integer"}}
+    assert tool.arg_types == {"a": int, "b": int}
+    assert tool.arg_desc == {"a": "No description provided. (Required)", "b": "No description provided. (Required)"}
+    assert await tool.acall(a=1, b=2) == 3
+
+
+@pytest.mark.asyncio
+@pytest.mark.extra
+async def test_convert_custom_tool_with_custom_class():
+    from langchain_core.tools import tool
+
+    class Profile(BaseModel):
+        name: str
+        age: int
+
+    @tool
+    def get_age(profile: Profile) -> int:
+        """Get the age of the profile."""
+        return profile.age
+    
+    tool = convert_langchain_tool(get_age)
+    assert tool.name == "get_age"
+    assert tool.desc == "Get the age of the profile."
+    assert tool.args == {"profile": {"title": "Profile", "type": "object", "properties": {"name": {"title": "Name", "type": "string"}, "age": {"title": "Age", "type": "integer"}}, "required": ["name", "age"]}}
+    assert tool.arg_types == {"profile": Profile}
+    assert tool.arg_desc == {"profile": "No description provided. (Required)"}
+    assert await tool.acall(profile=Profile(name="John", age=20)) == 20