Add convenience method to use LangChain community tools

docs/tools.md

@@ -409,6 +409,42 @@ print(test_model.last_model_request_parameters.function_tools)
 
 _(This example is complete, it can be run "as is")_
 
+If you have a function that lacks appropriate documentation (i.e. poorly named, no type information, poor docstring, use of *args or **kwargs and suchlike) then you can still turn it into a tool that can be effectively used by the agent with the `Tool.from_schema` function. With this you provide the name, description and JSON schema for the function directly:
+
+```python
+from pydantic_ai import Agent, Tool
+from pydantic_ai.models.test import TestModel
+
+
+def foobar(**kwargs) -> str:
+    return kwargs['a'] + kwargs['b']
+
+tool = Tool.from_schema(
+    function=foobar,
+    name='sum',
+    description='Sum two numbers.',
+    json_schema={
+        'additionalProperties': False,
+        'properties': {
+            'a': {'description': 'the first number', 'type': 'integer'},
+            'b': {'description': 'the second number', 'type': 'integer'},
+        },
+        'required': ['a', 'b'],
+        'type': 'object',
+    }
+)
+
+test_model = TestModel()
+agent = Agent(test_model, tools=[tool])
+
+result = agent.run_sync('testing...')
+print(result.output)
+#> {"sum":0}
+```
+
+
+Please note that validation of the tool arguments will not be performed, and this will pass all arguments as keyword arguments.
+
 ## Dynamic Function tools {#tool-prepare}
 
 Tools can optionally be defined with another function: `prepare`, which is called at each step of a run to
@@ -624,3 +660,32 @@ def my_flaky_tool(query: str) -> str:
     return 'Success!'
 ```
 Raising `ModelRetry` also generates a `RetryPromptPart` containing the exception message, which is sent back to the LLM to guide its next attempt. Both `ValidationError` and `ModelRetry` respect the `retries` setting configured on the `Tool` or `Agent`.
+
+## Use LangChain Tools {#langchain-tools}
+
+If you'd like to use a tool from LangChain's [community tool library](https://python.langchain.com/docs/integrations/tools/) with PydanticAI, you can use the `pydancic_ai.ext.langchain.tool_from_langchain` convenience method. Note that PydanticAI will not validate the arguments in this case -- it's up to the model to provide arguments matching the schema specified by the LangChain tool, and up to the LangChain tool to raise an error if the arguments are invalid.
+
+Here is how you can use it to augment model responses using a LangChain web search tool. This tool will need you to install the `langchain-community` and `duckduckgo-search` dependencies to work properly.
+
+```python {test="skip"}
+from langchain_community.tools import DuckDuckGoSearchRun
+
+from pydantic_ai import Agent
+from pydantic_ai.ext.langchain import tool_from_langchain
+
+search = DuckDuckGoSearchRun()
+search_tool = tool_from_langchain(search)
+
+agent = Agent(
+    'google-gla:gemini-2.0-flash',  # (1)!
+    tools=[search_tool],
+)
+
+result = agent.run_sync('What is the release date of Elden Ring Nightreign?')  # (2)!
+print(result.output)
+#> Elden Ring Nightreign is planned to be released on May 30, 2025.
+```
+
+
+1. While this task is simple Gemini 1.5 didn't want to use the provided tool. Gemini 2.0 is still fast and cheap.
+2. The release date of this game is the 30th of May 2025, which was confirmed after the knowledge cutoff for Gemini 2.0 (August 2024).

pydantic_ai_slim/pydantic_ai/_function_schema.py

@@ -7,7 +7,7 @@
 
 import inspect
 from collections.abc import Awaitable
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from inspect import Parameter, signature
 from typing import TYPE_CHECKING, Any, Callable, cast
 
@@ -43,9 +43,9 @@ class FunctionSchema:
     # if not None, the function takes a single by that name (besides potentially `info`)
     takes_ctx: bool
     is_async: bool
-    single_arg_name: str | None
-    positional_fields: list[str]
-    var_positional_field: str | None
+    single_arg_name: str | None = None
+    positional_fields: list[str] = field(default_factory=list)
+    var_positional_field: str | None = None
 
     async def call(self, args_dict: dict[str, Any], ctx: RunContext[Any]) -> Any:
         args, kwargs = self._call_args(args_dict, ctx)

pydantic_ai_slim/pydantic_ai/ext/langchain.py

@@ -0,0 +1,61 @@
+from typing import Any, Protocol
+
+from pydantic.json_schema import JsonSchemaValue
+
+from pydantic_ai.tools import Tool
+
+
+class LangChainTool(Protocol):
+    # args are like
+    # {'dir_path': {'default': '.', 'description': 'Subdirectory to search in.', 'title': 'Dir Path', 'type': 'string'},
+    #  'pattern': {'description': 'Unix shell regex, where * matches everything.', 'title': 'Pattern', 'type': 'string'}}
+    @property
+    def args(self) -> dict[str, JsonSchemaValue]: ...
+
+    def get_input_jsonschema(self) -> JsonSchemaValue: ...
+
+    @property
+    def name(self) -> str: ...
+
+    @property
+    def description(self) -> str: ...
+
+    def run(self, *args: Any, **kwargs: Any) -> str: ...
+
+
+__all__ = ('tool_from_langchain',)
+
+
+def tool_from_langchain(langchain_tool: LangChainTool) -> Tool:
+    """Creates a Pydantic tool proxy from a LangChain tool.
+
+    Args:
+        langchain_tool: The LangChain tool to wrap.
+
+    Returns:
+        A Pydantic tool that corresponds to the LangChain tool.
+    """
+    function_name = langchain_tool.name
+    function_description = langchain_tool.description
+    inputs = langchain_tool.args.copy()
+    required = sorted({name for name, detail in inputs.items() if 'default' not in detail})
+    schema: JsonSchemaValue = langchain_tool.get_input_jsonschema()
+    if 'additionalProperties' not in schema:
+        schema['additionalProperties'] = False
+    if required:
+        schema['required'] = required
+
+    defaults = {name: detail['default'] for name, detail in inputs.items() if 'default' in detail}
+
+    # restructures the arguments to match langchain tool run
+    def proxy(*args: Any, **kwargs: Any) -> str:
+        assert not args, 'This should always be called with kwargs'
+        kwargs = defaults | kwargs
+        return langchain_tool.run(kwargs)
+
+    return Tool.from_schema(
+        function=proxy,
+        name=function_name,
+        description=function_description,
+        json_schema=schema,
+    )

pydantic_ai_slim/pydantic_ai/tools.py

@@ -1,5 +1,6 @@
 from __future__ import annotations as _annotations
 
+import asyncio
 import dataclasses
 import json
 from collections.abc import Awaitable, Sequence
@@ -9,8 +10,8 @@
 from opentelemetry.trace import Tracer
 from pydantic import ValidationError
 from pydantic.json_schema import GenerateJsonSchema, JsonSchemaValue
-from pydantic_core import core_schema
-from typing_extensions import Concatenate, ParamSpec, TypeAlias, TypeVar
+from pydantic_core import SchemaValidator, core_schema
+from typing_extensions import Concatenate, ParamSpec, Self, TypeAlias, TypeVar
 
 from . import _function_schema, _utils, messages as _messages
 from .exceptions import ModelRetry, UnexpectedModelBehavior
@@ -63,7 +64,9 @@ class RunContext(Generic[AgentDepsT]):
     """The current step in the run."""
 
     def replace_with(
-        self, retry: int | None = None, tool_name: str | None | _utils.Unset = _utils.UNSET
+        self,
+        retry: int | None = None,
+        tool_name: str | None | _utils.Unset = _utils.UNSET,
     ) -> RunContext[AgentDepsT]:
         # Create a new `RunContext` a new `retry` value and `tool_name`.
         kwargs = {}
@@ -306,6 +309,45 @@ async def prep_my_tool(
         self.require_parameter_descriptions = require_parameter_descriptions
         self.strict = strict
 
+    @classmethod
+    def from_schema(
+        cls,
+        function: Callable[..., Any],
+        name: str,
+        description: str,
+        json_schema: JsonSchemaValue,
+    ) -> Self:
+        """Creates a Pydantic tool from a function and a JSON schema.
+
+        Args:
+            function: The function to call.
+                This will be called with keywords only, and no validation of
+                the arguments will be performed.
+            name: The unique name of the tool that clearly communicates its purpose
+            description: Used to tell the model how/when/why to use the tool.
+                You can provide few-shot examples as a part of the description.
+            json_schema: The schema for the function arguments
+
+        Returns:
+            A Pydantic tool that calls the function
+        """
+        function_schema = _function_schema.FunctionSchema(
+            function=function,
+            description=description,
+            validator=SchemaValidator(schema=core_schema.any_schema()),
+            json_schema=json_schema,
+            takes_ctx=False,
+            is_async=asyncio.iscoroutinefunction(function),
+        )
+
+        return cls(
+            function,
+            takes_ctx=False,
+            name=name,
+            description=description,
+            function_schema=function_schema,
+        )
+
     async def prepare_tool_def(self, ctx: RunContext[AgentDepsT]) -> ToolDefinition | None:
         """Get the tool definition.
 
@@ -327,7 +369,10 @@ async def prepare_tool_def(self, ctx: RunContext[AgentDepsT]) -> ToolDefinition
             return tool_def
 
     async def run(
-        self, message: _messages.ToolCallPart, run_context: RunContext[AgentDepsT], tracer: Tracer
+        self,
+        message: _messages.ToolCallPart,
+        run_context: RunContext[AgentDepsT],
+        tracer: Tracer,
     ) -> _messages.ToolReturnPart | _messages.RetryPromptPart:
         """Run the tool function asynchronously.