feat: Add intelligent tool matcher with semantic embeddings

- Implement ToolMatcher class using sentence transformers for semantic similarity
- Add fallback mechanisms: TF-IDF vectorization and simple keyword matching
- Support configurable similarity thresholds and maximum tool results
- Include comprehensive error handling and logging
- Provide methods for tool matching, similarity calculation, and tool management
- Enable intelligent task-tool matching based on names and descriptions

Author: Teeeio

requirements.txt

@@ -48,6 +48,8 @@ packaging==25.0
 pandas==2.2.3
 pillow==11.2.1
 psutil==7.0.0
+sentence-transformers==2.5.1
+scikit-learn==1.5.2
 pycparser==2.22
 pydantic==2.11.3
 pydantic-settings==2.10.1

slaver/config.yaml

@@ -1,6 +1,12 @@
 tool:
   # Has the model undergone targeted training on tool_calls
   support_tool_calls: true
+  # Tool matching configuration
+  matching:
+    # Maximum number of tools to match for each task
+    max_tools: 3
+    # Minimum similarity score threshold (0.0 to 1.0)
+    min_similarity: 0.1
 
 # Cloud Server Infos
 model:

slaver/run.py

@@ -19,6 +19,7 @@
 from mcp.client.stdio import stdio_client
 from mcp.client.streamable_http import streamablehttp_client
 from tools.utils import Config
+from tools.tool_matcher import ToolMatcher
 
 config = Config.load_config()
 collaborator = Collaborator.from_config(config=config["collaborator"])
@@ -39,6 +40,22 @@ def __init__(self):
         self.threads = []
         self.loop = asyncio.get_event_loop()
         self.robot_name = None
+        
+        # Initialize tool matcher with configuration
+        print(f"\n{'='*60}")
+        print(f"⚙️  INITIALIZING TOOL MATCHER")
+        print(f"{'='*60}")
+        print(f"Configuration loaded from config.yaml:")
+        print(f"  max_tools: {config['tool']['matching']['max_tools']}")
+        print(f"  min_similarity: {config['tool']['matching']['min_similarity']}")
+        
+        self.tool_matcher = ToolMatcher(
+            max_tools=config["tool"]["matching"]["max_tools"],
+            min_similarity=config["tool"]["matching"]["min_similarity"]
+        )
+        
+        print(f"✅ Tool matcher initialized successfully")
+        print(f"{'='*60}\n")
 
         signal.signal(signal.SIGINT, self._handle_signal)
         signal.signal(signal.SIGTERM, self._handle_signal)
@@ -108,8 +125,53 @@ async def _execute_task(self, task_data: Dict) -> None:
             return
 
         os.makedirs("./.log", exist_ok=True)
+        
+        # Use tool matcher to find relevant tools for the task
+        task = task_data["task"]
+        print(f"\n{'='*60}")
+        print(f"🔍 TOOL MATCHING FOR TASK")
+        print(f"{'='*60}")
+        print(f"Task: {task}")
+        print(f"Available tools: {len(self.tools)}")
+        
+        # Get matched tools with detailed logging
+        matched_tools = self.tool_matcher.match_tools(task)
+        
+        # Filter tools based on matching results
+        if matched_tools:
+            matched_tool_names = [tool_name for tool_name, _ in matched_tools]
+            filtered_tools = [tool for tool in self.tools 
+                           if tool.get("function", {}).get("name") in matched_tool_names]
+            
+            print(f"\n✅ MATCHING RESULTS:")
+            print(f"Matched tools count: {len(matched_tools)}")
+            
+            # Print tool names and scores only
+            for i, (tool_name, similarity_score) in enumerate(matched_tools, 1):
+                print(f"  {i}. {tool_name} (Score: {similarity_score:.4f})")
+            
+            print(f"\n📊 TOOL FILTERING:")
+            print(f"Original tools: {len(self.tools)}")
+            print(f"Filtered tools: {len(filtered_tools)}")
+            print(f"Reduction: {len(self.tools) - len(filtered_tools)} tools filtered out")
+            
+            # Show which tools were filtered out
+            if len(filtered_tools) < len(self.tools):
+                filtered_names = {tool.get("function", {}).get("name") for tool in filtered_tools}
+                all_names = {tool.get("function", {}).get("name") for tool in self.tools}
+                filtered_out_names = all_names - filtered_names
+                if filtered_out_names:
+                    print(f"Filtered out tools: {', '.join(sorted(filtered_out_names))}")
+        else:
+            filtered_tools = self.tools
+            print(f"\n⚠️  NO SPECIFIC TOOLS MATCHED")
+            print(f"Using all {len(self.tools)} available tools")
+            print(f"Consider adjusting min_similarity threshold in config")
+        
+        print(f"{'='*60}\n")
+        
         agent = ToolCallingAgent(
-            tools=self.tools,
+            tools=filtered_tools,
             verbosity_level=2,
             model=self.model,
             model_path=self.model_path,
@@ -118,7 +180,7 @@ async def _execute_task(self, task_data: Dict) -> None:
             collaborator=self.collaborator,
             tool_executor=self.session.call_tool,
         )
-        task = task_data["task"]
+        
         result = await agent.run(task)
         self._send_result(
             robot_name=self.robot_name,
@@ -195,6 +257,26 @@ async def connect_to_robot(self):
             for tool in response.tools
         ]
         print("Connected to robot with tools:", str(self.tools))
+        
+        # Train the tool matcher with the available tools
+        print(f"\n{'='*60}")
+        print(f"🔄 TRAINING TOOL MATCHER")
+        print(f"{'='*60}")
+        print(f"Available tools: {len(self.tools)}")
+        
+        # Show tool details
+        for i, tool in enumerate(self.tools, 1):
+            name = tool.get("function", {}).get("name", "Unknown")
+            description = tool.get("function", {}).get("description", "No description")
+            print(f"  {i}. {name}")
+            print(f"     {description}")
+        
+        # Train the matcher
+        self.tool_matcher.fit(self.tools)
+        print(f"\n✅ Tool matcher training completed")
+        print(f"Training data: {len(self.tools)} tools")
+        print(f"Configuration: max_tools={self.tool_matcher.max_tools}, min_similarity={self.tool_matcher.min_similarity}")
+        print(f"{'='*60}\n")
 
         """Complete robot registration with thread management"""
         robot_name = config["robot"]["name"]