In the process of developing a framework for implementing AI agents, we have explored core components like personas, instructions, tasks, and execution strategies. These elements shape the cognitive processes of the agents. However, in the modern interconnected enterprise environment, cognitive processes alone are insufficient. Agents must be able to act, extending beyond their internal knowledge to interact with the external world.
This is where tools come into play — they are the hands and eyes of our AI agents, extending their capabilities far beyond simple text generation and static knowledge cutoffs. Just as human employees rely on various software tools, databases, and APIs to accomplish their tasks, AI agents need similar capabilities to be truly effective in an enterprise setting.
The impact of tool integration cannot be overstated. With properly implemented tool support, agents transform from simple chat interfaces into capable digital workers that can:
- Provide Current Information: Instead of relying on training data that may be months or years old, agents can fetch the latest information in real-time.
- Perform Complex Tasks: By combining multiple tools, agents can handle sophisticated workflows that require interaction with various systems and services.
- Validate and Verify: Tools allow agents to fact-check their responses against authoritative sources, significantly improving accuracy and reliability.
- Integrate with Enterprise Systems: Agents can seamlessly work with existing enterprise infrastructure, from CRM systems to custom internal tools.
- Scale Operations: By automating interactions with various tools and services, agents can handle increased workloads without linear resource scaling.
However, implementing tool support isn’t just about connecting APIs — it requires careful consideration of architecture, security, error handling, and user experience. In this article, we’ll explore how to design and implement a robust tool system for AI agents, using practical examples that you can adapt for your own enterprise applications.
Understanding Tool Architecture
At its core, tool support consists of three main components:
- A base Tool class that defines the interface;
- Concrete tool implementations; and
- A registry system to manage available tools.
Let’s break down each component and see how they work together.
The Base Tool Class
First, let’s look at the abstract base class that all tools must implement:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44
|
from abc import ABC, abstractmethod from typing import Any, Dict, Optional from dataclasses import dataclass
@dataclass class ToolResult: “””Represents the result of a tool execution.””” success: bool data: Any error: Optional[str] = None
class Tool(ABC): “””Base class for all tools.”””
@property @abstractmethod def name(self) –> str: “””The name of the tool.””” pass
@property @abstractmethod def description(self) –> str: “””Description of what the tool does.””” pass
@property @abstractmethod def parameters(self) –> Dict[str, str]: “””Dictionary of parameter names and their descriptions.””” pass
@abstractmethod def execute(self, **kwargs) –> ToolResult: “””Execute the tool with the given parameters.””” pass
def to_prompt_format(self) –> str: “””Convert tool information to a format suitable for prompts.””” params_str = “\n”.join(f” – {name}: {desc}” for name, desc in self.parameters.items()) return f“””Tool: {self.name} Description: {self.description} Parameters: {params_str}””” |
Tool Registry System
The tool registry manages the available tools and provides methods to access them:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36
|
class ToolRegistry: “””Registry for managing available tools.”””
def __init__(self): self._tools: Dict[str, Tool] = {}
def register(self, tool: Tool) –> None: “””Register a new tool.””” if not isinstance(tool, Tool): raise TypeError(“Tool must be an instance of Tool class”) self._tools[tool.name] = tool
def get_tool(self, name: str) –> Optional[Tool]: “””Get a tool by name.””” return self._tools.get(name)
def list_tools(self) –> List[str]: “””List all registered tool names.””” return list(self._tools.keys())
def get_tools_prompt(self) –> str: “””Get a formatted string of all tools for use in prompts.””” if not self._tools: return “No tools available.”
tools_str = “\n\n”.join(tool.to_prompt_format() for tool in self._tools.values()) return f“””Available Tools:
{tools_str}
To use a tool, specify it in your response as: Tool: [tool_name] Parameters: – param1: value1 – param2: value2 “”” |
Implementing Specific Tools
Let’s now look at two concrete tool implementations: Wikipedia search and web search.
Wikipedia Search Tool
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48
|
import wikipedia from typing import Dict, Any from tools import Tool, ToolResult
class WikipediaTool(Tool): “””Tool for searching Wikipedia”””
@property def name(self) –> str: return “wikipedia_search”
@property def description(self) –> str: return “Search Wikipedia for information about a topic”
@property def parameters(self) –> Dict[str, Dict[str, Any]]: return { “query”: { “type”: “string”, “description”: “The Wikipedia search query” } }
def execute(self, **kwargs) –> ToolResult: try: query = kwargs.get(“query”) print(f“Searching Wikipedia for: {query}”) search_results = wikipedia.search(query) if not search_results: return ToolResult( success=True, data=“No Wikipedia articles found for the query.” )
page = wikipedia.page(search_results[0]) summary = page.summary[:500] + “…”
return ToolResult( success=True, data=f“Title: {page.title}\nSummary: {summary}” ) except Exception as e: return ToolResult( success=False, data=“”, error=f“Wikipedia search failed: {str(e)}” ) |
Web Search Tool
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68
|
import os from typing import Dict, Any from tools import Tool, ToolResult from tavily import TavilyClient
class WebSearchTool(Tool): “””Tool for performing web searches using Tavily API”””
def __init__(self): “””Initialize the web search tool with API key.””” self.api_key = os.getenv(‘TAVILY_API_KEY’, ”) if not self.api_key: raise ValueError(“TAVILY_API_KEY environment variable not set”)
@property def name(self) –> str: return “web_search”
@property def description(self) –> str: return “Search the web for information about a topic”
@property def parameters(self) –> Dict[str, Dict[str, Any]]: return { “query”: { “type”: “string”, “description”: “The search query to look up” } }
def execute(self, **kwargs) –> ToolResult: try: query = kwargs.get(“query”) if not query: return ToolResult( success=False, data=“”, error=“No query provided” )
client = TavilyClient(api_key=self.api_key) search_response = client.search(query=query)
# Take the top 3 results results = search_response[‘results’][:3]
# Format results formatted_results = [] for result in results: formatted_results.append({ “title”: result.get(‘title’, ‘No title’), “content”: result.get(‘content’, ‘No content’), “url”: result.get(‘url’, ‘No URL’) })
formatted_output = self._format_search_results(formatted_results)
return ToolResult( success=True, data=formatted_output ) except Exception as e: return ToolResult( success=False, data=“”, error=f“Web search failed: {str(e)}” ) |
Using Tools With Agents
Here’s how to integrate tools with an agent:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
|
from agent import Agent from wikipedia_tool import WikipediaTool from websearch_tool import WebSearchTool
# Initialize agent and tools agent = Agent(“research_agent”) wiki_tool = WikipediaTool() web_tool = WebSearchTool()
# Register tools with the agent agent.tools = [wiki_tool, web_tool]
# Set up agent persona agent.persona = “””I am a research assistant with access to both Wikipedia and web search. I can find information from multiple sources to provide comprehensive answers.”””
# Execute a task response = agent.execute(“What are the latest developments in quantum computing?”) print(response) |
How Tool Execution Works
When an agent uses a tool, the process follows these steps:
- The agent receives a task and determines if it needs to use a tool.
- If a tool is needed, the agent formats its request using the specified format:
CopyTool: [tool_name]
Parameters:
- param1: value1 - The agent’s response is parsed to extract tool usage information.
- The tool is executed with the provided parameters.
- The tool’s result is incorporated into the agent’s response.
The parse_tool_usage function handles extracting tool information from the agent’s response:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28
|
def parse_tool_usage(response: str) –> Optional[Dict[str, Any]]: “””Parse a response string to extract tool usage information.””” try: if “Tool:” not in response: return None
lines = response.split(‘\n’) tool_info = {}
# Find tool name for i, line in enumerate(lines): if line.startswith(“Tool:”): tool_info[“name”] = line.replace(“Tool:”, “”).strip() break
# Find parameters params = {} for line in lines: if “:” in line and “-“ in line: param_line = line.split(“:”, 1) param_name = param_line[0].replace(“-“, “”).strip() param_value = param_line[1].strip() params[param_name] = param_value
tool_info[“parameters”] = params return tool_info except Exception: return None |
Best Practices for Tool Implementation
- Error Handling: Always wrap tool execution in try-except blocks and return meaningful error messages.
- Clear Documentation: Provide clear descriptions and parameter specifications for each tool.
- Consistent Interface: Follow the Tool base class interface consistently.
- Result Formatting: Format tool results in a clear, readable way.
- Resource Management: Handle API keys and external resources securely.
- Modularity: Keep tool implementations independent and focused on a single responsibility.
Conclusion
Tool support is a crucial feature that makes AI agents more capable and practical for real-world applications. By following the patterns and practices outlined in this article, you can create a robust and extensible tool system for your agents. The combination of a clear base interface, an efficient registry system, and well-implemented concrete tools provides a solid foundation for building sophisticated agent capabilities.
Remember that tools should be designed to be:
- Reusable across different agents;
- Easy to maintain and update;
- Well-documented for other developers; and
- Robust in handling errors and edge cases.
With these principles in mind, you can create powerful tools that enhance your agents’ capabilities and make them more useful for real-world tasks.
This concludes the series on AI agents, where we implemented an end-to-end framework to explore crucial capabilities and functions agents.
YOUTUBE.COM/THENEWSTACK
Tech moves fast, don’t miss an episode. Subscribe to our YouTube
channel to stream all our podcasts, interviews, demos, and more.
