Tool Discovery: Finding the Right Tools

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))

3. Semantic Search

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