Add custom and built-in Langchain tools for mathematical operations and search functionality

Author: SayamAlt

Generative AI with Langchain/Tools/base_tool.py

@@ -0,0 +1,40 @@
+from langchain.tools import BaseTool
+from typing import Type
+from pydantic import BaseModel, Field
+import asyncio
+
+class MultiplyInput(BaseModel):
+ a: int = Field(..., description="First number to multiply")
+ b: int = Field(..., description="Second number to multiply")
+ 
+# On inheriting from BaseTool class, we can create a custom tool
+class MultiplyTool(BaseTool):
+ """Multiply two numbers."""
+
+ name: str = "multiply"
+ description: str = "Multiply two numbers"
+ args_schema: Type[BaseModel] = MultiplyInput
+ 
+ def _run(self, a: int, b: int) -> int:
+ return a * b
+ 
+ async def _arun(self, a: int, b: int) -> int: # async method can be used to ensure concurrency
+ return a * b
+ 
+# multiply_tool = MultiplyTool()
+# result = multiply_tool.invoke({'a': 2, 'b': 3})
+# print(result)
+
+# print(multiply_tool.name)
+# print(multiply_tool.description)
+# print(multiply_tool.args)
+
+async def _():
+ multiply_tool = MultiplyTool()
+ result = await multiply_tool.ainvoke({'a': 6, 'b': 7})
+ print("Async Result:", result)
+ print("Tool name:", multiply_tool.name)
+ print("Description:", multiply_tool.description)
+ print("Args Schema:", multiply_tool.args_schema.schema())
+
+asyncio.run(_())

Generative AI with Langchain/Tools/built_in_tools.py

@@ -0,0 +1,18 @@
+from langchain_community.tools import DuckDuckGoSearchRun, ShellTool
+
+# Built-in Tool - DuckDuckGo Search
+search_tool = DuckDuckGoSearchRun() # Tools are runnables
+results = search_tool.invoke('top news in India today')
+print(results)
+
+print(search_tool.name) # Name of the tool
+print(search_tool.description) # Description of the tool
+print(search_tool.args) # Arguments of the tool
+print(search_tool.metadata) # Metadata of the tool
+
+# Built-in Tool - Shell Tool
+shell_tool = ShellTool()
+results = shell_tool.invoke('ls -l')
+print(results)
+
+# Refer to Langchain documentation for more built-in tools

Generative AI with Langchain/Tools/custom_toolkits.py

@@ -0,0 +1,76 @@
+from langchain_core.tools import tool
+
+# Custom tools
+@tool
+def add(x: int, y: int) -> int:
+ """Adds two numbers."""
+ return x + y
+
+@tool
+def subtract(x: int, y: int) -> int:
+ """Subtracts two numbers."""
+ return x - y
+
+@tool
+def multiply(x: int, y: int) -> int:
+ """Multiplies two numbers."""
+ return x * y
+
+@tool
+def divide(x: int, y: int) -> float:
+ """Divides two numbers."""
+ return x / y
+
+@tool
+def power(x: int, y: int) -> int:
+ """Raises x to the power of y."""
+ return x ** y
+
+def calculate_factorial(n: int) -> int:
+ """Calculates the factorial of n."""
+ if n < 0:
+ raise ValueError("Factorial is not defined for negative numbers.")
+ if n == 0 or n == 1:
+ return 1
+ return n * calculate_factorial(n - 1)
+@tool
+def factorial(x: int) -> int:
+ """Calculates the factorial of x."""
+ return calculate_factorial(x)
+
+class MathToolkit:
+ """A toolkit for performing various mathematical operations."""
+
+ def __init__(self):
+ self.tools = [add, subtract, multiply, divide, power, factorial]
+
+ def get_tools(self):
+ """Returns the available tools."""
+ return self.tools
+ 
+ def execute_tool(self, tool_name: str, *args):
+ """Executes a tool by its name with the given arguments."""
+ for tool in self.tools:
+ if tool.name == tool_name:
+ input_keys = tool.args
+ if len(input_keys) != len(args):
+ raise ValueError(f"{tool_name} expects {len(input_keys)} arguments, got {len(args)}.")
+ input_dict = dict(zip(input_keys, args))
+ return tool.invoke(input_dict)
+ raise ValueError(f"Tool {tool_name} not found in toolkit.")
+ 
+toolkit = MathToolkit()
+tools = toolkit.get_tools()
+
+for tool in tools:
+ print(tool.name,"-->",tool.description)
+ 
+print("Addition result:", toolkit.execute_tool("add", 5, 3))
+print("Subtraction result:", toolkit.execute_tool("subtract", 5, 3))
+print("Multiplication result:", toolkit.execute_tool("multiply", 5, 3))
+print("Division result:", toolkit.execute_tool("divide", 5, 3))
+print("Power result:", toolkit.execute_tool("power", 5, 3))
+print("Factorial result:", toolkit.execute_tool("factorial", 5))
+ 
+
+ 

Generative AI with Langchain/Tools/custom_tools.py

@@ -0,0 +1,30 @@
+from langchain_core.tools import tool
+from pydantic import BaseModel, Field
+
+# Custom Tools
+# Step 1 - Create a function
+def multiply(a, b):
+ """Multiply two numbers."""
+ return a * b
+
+# Step 2 - Add type hints
+def multiply(a: int, b: int) -> int:
+ """Multiply two numbers."""
+ return a * b
+
+# Step 3 - add tool decorator
+@tool
+def multiply(a: int, b: int) -> int:
+ """Multiply two numbers."""
+ return a * b
+
+# Step 4 - invoke the tool
+result = multiply.invoke({'a': 5, 'b': 4})
+print(result)
+
+# Tool attributes
+print(multiply.name)
+print(multiply.description)
+print(multiply.args)
+
+print(multiply.args_schema.model_json_schema()) # Passed to the LLM - tools are not sent, its schema is sent

Generative AI with Langchain/Tools/structured_tool.py

@@ -0,0 +1,25 @@
+from langchain.tools import StructuredTool
+from pydantic import BaseModel, Field
+
+# Custom Tools - Using StructuredTool
+class MultiplyInput(BaseModel):
+ a: int = Field(required=True, description="First number to multiply")
+ b: int = Field(required=True, description="Second number to multiply")
+ 
+def multiply_two_numbers(a: int, b: int) -> int:
+ """Multiply two numbers."""
+ return a * b
+
+multiply_tool = StructuredTool.from_function(
+ func=multiply_two_numbers,
+ name="multiply",
+ description="Multiply two numbers",
+ args_schema=MultiplyInput
+)
+
+result = multiply_tool.invoke({'a': 6, 'b': 9})
+print(result)
+
+print(multiply_tool.name)
+print(multiply_tool.description)
+print(multiply_tool.args)