Lesson 02 � Intermediate Skill

TOOL USE:
AGENTS KE HAATH-PAIR.

Tools se agents real-world mein interact karte hain � web search, API calls, file operations sab tools hain. Bina tools ke agent sirf baatein karta hai, kaam nahi karta. Tools hi agents ko powerful banate hain.

? 20 min✓ Intermediate✓ Prerequisite: Agent Architecture

WHY: Tools agents ke liye kyun zaroori hain?

Normal LLM sirf text generate karta hai. Lekin jab aap bolte ho "Mumbai ka weather batao" � agent ko actually weather API call karni padegi. Tools woh bridge hain jo AI ko real world se connect karte hain. Jaise insaan ke haath kaam karne ke liye hain, waise agents ke liye tools hain.

FUNCTIONS

Python functions jo specific kaam karti hain � search, calculate, read file. Har tool ek function hai jo input leta hai aur output deta hai.

SCHEMA

Tool ka input/output format define karna � kaunsa parameter chahiye, kya type hai, kya return hoga. LLM ko samjhane ke liye schema zaroori hai.

REGISTRY

Available tools ka catalog � kaunse tools hain, kya karte hain, kaise use karein. Agent ko pata hona chahiye ki kaunsa tool kab use karna hai.

ERROR HANDLING

Graceful failure � tool fail ho jaye toh kya karein✓ Retry, fallback, ya user ko batayein. Robust agents hamesha error handle karte hain.

Tool = Function

Har tool basically ek Python function hai. Simple hai � input lo, kaam karo, output do. Lekin tool mein ek cheez aur hoti hai: description. LLM ko batana padega ki yeh tool kya karta hai.

# Tool = Function + Description
def search_web(query):
 """Web pe search karo"""
 return f"Results for: {query}"

def calculate(expression):
 """Math calculate karo"""
 try:
 return eval(expression)
 except:
 return "Invalid expression"

def read_file(filepath):
 """File ka content padho"""
 return f"Content of {filepath}"

# Tools ke saath function ban gaya
print(search_web("Python tutorial"))
print(calculate("2 + 2"))
print(read_file("data.txt"))

Schema: LLM ko tools kaise samjhayein?

LLM ko tool samjhane ke liye schema chahiye � kaunsa parameter hai, kya type hai, kya required hai. JSON Schema format mein define karte hain.

# Tool Schema - LLM ko samjhane ke liye
tool_schema = {
 "name": "search_web",
 "description": "Web pe search karo aur results lao",
 "parameters": {
 "type": "object",
 "properties": {
 "query": {
 "type": "string",
 "description": "Search karne ka query"
 },
 "num_results": {
 "type": "integer",
 "description": "Kitne results chahiye",
 "default": 5
 }
 },
 "required": ["query"]
 }
}

# Function bhi schema ke according
def search_web(query, num_results=5):
 """Web pe search karo"""
 return f"Found {num_results} results for: {query}"

# Ab LLM samajh jayega ki kaise call karna hai
print(f"Tool: {tool_schema['name']}")
print(f"Description: {tool_schema['description']}")
print(f"Required params: {tool_schema['parameters']['required']}")

ℹ

Key insight: Schema isliye zaroori hai kyunki LLM ko function call karne ka tarika chahiye. Bina schema ke LLM guess karega ki parameters kya hain � aur galat call karega.

Tool Registry: Tool Catalog

Registry ek catalog hai � saare tools ek jagah hain. Agent registry se tool dhundhta hai, call karta hai. Clean pattern hai for managing multiple tools.

# Tool registry pattern
class ToolRegistry:
 def __init__(self):
 self.tools = {}
 
 def register(self, name, func, description):
 self.tools[name] = {
 "func": func,
 "description": description
 }
 
 def execute(self, name, **kwargs):
 if name in self.tools:
 return self.tools[name]["func"](**kwargs)
 return f"Tool {name} not found"
 
 def list_tools(self):
 return {name: tool["description"] 
 for name, tool in self.tools.items()}

# Create tools
registry = ToolRegistry()
registry.register("search", lambda q: f"Results for {q}", "Web search")
registry.register("calculate", lambda expr: eval(expr), "Calculate math")
registry.register("get_time", lambda: "2024-01-01 12:00", "Get current time")

print(registry.list_tools())
print(registry.execute("search", q="Python"))
print(registry.execute("calculate", expr="2+2"))

Error Handling: Graceful Failure

Tools kabhi kabhi fail hoti hain � network down, invalid input, ya API limit. Robust agents hamesha error handle karte hain aur user ko clear message dete hain.

# Robust tool with error handling
class SafeTool:
 def __init__(self, name, func):
 self.name = name
 self.func = func
 self.call_count = 0
 self.error_count = 0
 
 def execute(self, **kwargs):
 self.call_count += 1
 try:
 result = self.func(**kwargs)
 return {"success": True, "result": result}
 except Exception as e:
 self.error_count += 1
 return {"success": False, "error": str(e)}
 
 def stats(self):
 return f"Calls: {self.call_count}, Errors: {self.error_count}"

# Safe calculator
def safe_calc(expr):
 allowed = set("0123456789+-*/.() ")
 if not all(c in allowed for c in expr):
 raise ValueError("Invalid characters in expression")
 return eval(expr)

calc_tool = SafeTool("calculator", safe_calc)
print(calc_tool.execute(expr="2 + 3"))
print(calc_tool.execute(expr="10 / 0")) # Error handle ho jayega
print(calc_tool.execute(expr="rm -rf /")) # Security check
print(calc_tool.stats())

Real-World Tool Example

Ab ek complete example dekhte hain � agent jo multiple tools use karta hai aur har tool ka schema defined hai.

# Complete agent with tools and schemas
class AgentWithTools:
 def __init__(self):
 self.registry = ToolRegistry()
 self._register_default_tools()
 
 def _register_default_tools(self):
 # Tool 1: Web Search
 self.registry.register(
 "search",
 lambda q: f"Top results for '{q}': [link1, link2, link3]",
 "Web pe search karo"
 )
 
 # Tool 2: Calculator
 self.registry.register(
 "calculate",
 lambda expr: f"{expr} = {eval(expr)}",
 "Math expression calculate karo"
 )
 
 # Tool 3: File Operations
 self.registry.register(
 "read_file",
 lambda path: f"Content of {path}: [sample data]",
 "File ka content padho"
 )
 
 # Tool 4: API Call
 self.registry.register(
 "api_call",
 lambda url, method="GET": f"{method} {url} -> 200 OK",
 "External API call karo"
 )
 
 def get_tools_for_llm(self):
 tools = self.registry.list_tools()
 return [{"name": k, "desc": v} for k, v in tools.items()]
 
 def run(self, task):
 print(f"Task: {task}")
 print(f"Available tools: {self.get_tools_for_llm()}")
 
 # Simple task routing
 if "search" in task.lower():
 return self.registry.execute("search", q=task)
 elif "calculate" in task.lower():
 return self.registry.execute("calculate", expr="2+2")
 else:
 return "Task understood, processing..."

# Use the agent
agent = AgentWithTools()
print(agent.run("Search for Python tutorials"))
print(agent.run("Calculate 5 * 3"))
print(agent.run("Read my data file"))

Try it: Build a Tool Registry

Yahan apna tool registry banao � tools register karo, execute karo, aur dekho kaise kaam karta hai.

Tool Registry BuilderApna khud ka tool registry banayein

main.py

# Tool Registry Example
# Apna tool registry banayein aur test karein

class ToolRegistry:
 def __init__(self):
 self.tools = {}
 
 def register(self, name, func, description):
 self.tools[name] = {
 "func": func,
 "description": description
 }
 
 def execute(self, name, **kwargs):
 if name in self.tools:
 return self.tools[name]["func"](**kwargs)
 return f"Tool {name} not found"
 
 def list_tools(self):
 return {name: tool["description"] 
 for name, tool in self.tools.items()}

# Create registry
registry = ToolRegistry()

# Register tools
registry.register("search", lambda q: f"Results for {q}", "Web search")
registry.register("calculate", lambda expr: eval(expr), "Calculate math")
registry.register("get_time", lambda: "2024-01-01 12:00", "Get current time")
registry.register("greet", lambda name: f"Hello, {name}!", "Greet someone")

# List all tools
print("=== Available Tools ===")
print(registry.list_tools())

# Execute tools
print("\n=== Using Tools ===")
print(registry.execute("search", q="Python tutorial"))
print(registry.execute("calculate", expr="2 + 2"))
print(registry.execute("get_time"))
print(registry.execute("greet", name="DSWallah"))

# Test error handling
print("\n=== Error Handling ===")
print(registry.execute("nonexistent")) # Tool not found

# Add your own tool!
# registry.register("my_tool", lambda x: f"Result: {x}", "My custom tool")
# print(registry.execute("my_tool", x="hello"))

Optional input (har line ek input)

Run Python dabayein

Exercise: Test Your Knowledge

Quick check

"Tool registry kya hai?"

Socho: agent ke paas bahut saare tools hain, unhe organize kaise karein✓ Ek catalog ya list ki tarah socho.

Key Takeaways

Tools = Functions: Har tool ek Python function hai jo input leta hai aur output deta hai.
Schema zaroori hai: LLM ko tool samjhane ke liye schema chahiye � parameters, types, description.
Registry pattern: Tools ko ek jagah register karo, execute karo. Clean aur scalable hai.
Error handling: Tools fail honge � gracefully handle karo, fallback do, user ko inform karo.
Real power: Tools hi agents ko real world se connect karte hain � bina tools ke agent sirf text hai.

Tool Use basics complete?

Ab Memory Systems par chalo � taaki aap samajh sako ki agents ko yaad kaise rakhte hain aur context kaise maintain karte hain.

TOOL USE:AGENTS KE HAATH-PAIR.