Skip to content

Tool Discovery

Overview

As tool collections grow, finding the right tool becomes critical.

Tool discovery bridges the gap between what an agent needs and what tools are available.

Discovery Approaches

1. Static Registry

TOOLS = {
 "search": search_tool,
 "calculate": calculator_tool,
 "send_email": email_tool,
 "fetch_data": database_tool
}

available_tools = list(TOOLS.keys())

2. Dynamic Discovery

class ToolDiscovery:
 def discover_tools(self, agent_intent):
 """Find tools matching agent intent"""

 # Search by keywords
 keywords = extract_keywords(agent_intent)
 matching = [
 tool for tool in self.tools 
 if any(kw in tool.keywords for kw in keywords)
]

 # Rank by relevance
 return sorted(matching, key=lambda t: t.relevance(agent_intent))

def find_tools_for_task(task_description, tools):
 """Find tools using semantic similarity"""

 # Embed task description
 task_embedding = embedder.encode(task_description)

 # Find similar tool descriptions
 similarities = []
 for tool in tools:
 tool_embedding = embedder.encode(tool.description)
 similarity = cosine_similarity(task_embedding, tool_embedding)
 similarities.append((tool, similarity))

 # Return top matches
 return sorted(similarities, key=lambda x: x[1], reverse=True)

4. LLM-Based Selection

def agent_selects_tools(goal, available_tools):
 """Let LLM choose best tools for goal"""

 tool_descriptions = format_tool_list(available_tools)

 prompt = f"""
 Goal: {goal}

 Available tools:
 {tool_descriptions}

 Which tools would help achieve this goal?
 Explain your reasoning.
 """

 response = llm.generate(prompt)
 selected_tools = parse_tool_selection(response)
 return selected_tools

Tool Metadata for Discovery

tool_metadata = {
 "name": "search_documents",
 "description": "Search documents by keyword or semantic similarity",
 "keywords": ["search", "find", "query", "documents"],
 "category": "retrieval",
 "input_types": ["string"],
 "output_type": "list",
 "use_cases": ["finding information", "research", "Q&A"],
 "related_tools": ["summarize", "extract_key_points"]
}

Plugin System

class PluginManager:
 """Dynamically load and discover plugins"""

 def __init__(self, plugin_dir):
 self.plugin_dir = plugin_dir
 self.tools = {}

 def load_plugins(self):
 """Discover and load all plugins"""
 for plugin_file in os.listdir(self.plugin_dir):
 if plugin_file.endswith('.py'):
 module = import_module(plugin_file)
 if hasattr(module, 'tool'):
 self.register(module.tool)

 def register(self, tool):
 self.tools[tool.name] = tool

 def get_tools_by_capability(self, capability):
 return [t for t in self.tools.values() 
 if capability in t.capabilities]

Best Practices

  1. Organize by category for faster discovery
  2. Write clear descriptions so tools are findable
  3. Tag with keywords for semantic search
  4. Version tools to manage upgrades
  5. Monitor discovery accuracy to improve

-

Last Updated: August 9, 2026