AI tools now have semantic search

Author: gradrix

neural_engine/core/domain_router.py

@@ -4,51 +4,108 @@
 This improves accuracy by using domain-specific experts instead of
 one general-purpose LLM trying to handle everything.
 
-Uses micro-LLM approach: small focused LLM call for domain detection.
-No regex patterns - generalizable and maintainable.
+Uses semantic tool discovery to determine domain - no hardcoded keywords!
+The domain is inferred from which tools match the goal semantically.
 """
 
-from typing import Optional
+from typing import Optional, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from neural_engine.core.tool_discovery import ToolDiscovery
 
 
 class DomainRouter:
     """
     Routes user goals to specialized domain handlers.
     
-    Domains:
-    - memory: Memory read/write operations
-    - strava: Strava API operations
-    - calculator: Mathematical calculations
-    - general: Everything else (default)
+    Domains are INFERRED from tool metadata, not hardcoded:
+    - If top matching tools have domain="fitness" → route to strava specialist
+    - If top matching tools have domain="memory" → route to memory specialist  
+    - Otherwise → general
     
-    Uses small LLM call for robust, generalizable domain detection.
+    This is the semantic, generalizable approach!
     """
 
-    def __init__(self, ollama_client=None):
-        """Initialize domain router with optional LLM client."""
+    def __init__(self, ollama_client=None, tool_discovery: Optional['ToolDiscovery'] = None):
+        """Initialize domain router with optional LLM client and tool discovery."""
         self.ollama_client = ollama_client
+        self.tool_discovery = tool_discovery
 
     def detect_domain(self, goal: str) -> str:
         """
-        Detect the domain for a given goal using per-domain voting.
+        Detect the domain for a given goal using semantic tool matching.
+        
+        NEW approach:
+        1. Use tool_discovery to find semantically matching tools
+        2. Look at the domain metadata of top matches
+        3. Route to the dominant domain
         
-        Each domain gets asked: "Does this goal belong to YOUR domain?"
-        Highest confidence wins.
+        This means "show me my runs from last week" will:
+        - Match strava_get_my_activities (domain="fitness")
+        - Route to strava domain
+        
+        Without any hardcoded keywords!
         
         Args:
             goal: User goal text
         
         Returns:
             Domain name ("memory", "strava", "calculator", "general")
         """
-        # If no LLM client, use fast keyword fallback
-        if not self.ollama_client:
-            return self._keyword_fallback(goal)
+        # Try semantic tool discovery first (the smart way!)
+        if self.tool_discovery:
+            domain = self._detect_via_tool_discovery(goal)
+            if domain != "general":
+                return domain
+        
+        # Fallback to LLM voting if tool discovery didn't give clear result
+        if self.ollama_client:
+            return self._detect_via_llm_voting(goal)
+        
+        # Last resort: keyword fallback
+        return self._keyword_fallback(goal)
+    
+    def _detect_via_tool_discovery(self, goal: str) -> str:
+        """
+        Detect domain by looking at which tools match semantically.
+        
+        This is the CORE innovation - no keywords needed!
+        """
+        # Get top 5 semantically matching tools
+        candidates = self.tool_discovery.semantic_search(goal, n_results=5)
+        
+        if not candidates:
+            return "general"
 
-        # Vote each domain
+        # Count domains from tool metadata
+        domain_scores = {}
+        for i, candidate in enumerate(candidates):
+            # Weight by position (first match matters more)
+            weight = 1.0 / (i + 1)
+            
+            # Get domain from metadata (stored during indexing)
+            domain = candidate.get('domain', 'general')
+            
+            # Map fitness domain to strava (for specialist routing)
+            if domain == 'fitness':
+                domain = 'strava'
+            
+            domain_scores[domain] = domain_scores.get(domain, 0) + weight
+        
+        # Return highest scoring domain
+        if domain_scores:
+            best_domain = max(domain_scores, key=domain_scores.get)
+            # Only return if it has significant score
+            if domain_scores[best_domain] > 0.5:
+                return best_domain
+        
+        return "general"
+    
+    def _detect_via_llm_voting(self, goal: str) -> str:
+        """Fallback: Use LLM to vote on domain."""
         domains = [
-            ("memory", "personal user information stored previously: remembering user's name, preferences, past conversations, things the user told you to remember"),
-            ("strava", "fitness activities, running, cycling, workouts, exercise data from Strava"),
+            ("memory", "retrieving or storing PERSONAL INFORMATION that the user previously told you (their name, preferences, favorites). NOT for external data like fitness activities or API data."),
+            ("strava", "fitness activities, running data, cycling, workouts, exercise tracking from Strava API - including 'runs', 'rides', 'activities', recent fitness data"),
             ("calculator", "mathematical calculations, numbers, arithmetic operations"),
         ]
 
@@ -61,6 +118,11 @@ def detect_domain(self, goal: str) -> str:
 Does this goal belong to the {domain_name} domain?
 ({domain_desc})
 
+IMPORTANT:
+- "memory" is ONLY for recalling things the USER TOLD YOU (like their name, preferences)
+- "strava" is for fitness data like runs, rides, activities (even if it says "my runs")
+- If the goal asks about exercise/fitness activities, answer NO for memory, YES for strava
+
 Answer YES or NO with confidence 0-100:
 YES if goal clearly matches this domain
 NO if goal doesn't match this domain

neural_engine/core/intent_classifier_neuron.py

@@ -339,9 +339,11 @@ def _classify_zeroshot(self, goal: str) -> str:
                 "role": "system",
                 "content": (
                     "You are an intent classifier. Classify user goals as either:\n"
-                    "- 'generative' (creative writing, stories, poems, general knowledge)\n"
-                    "- 'tool_use' (calculations, data retrieval, API calls, specific actions)\n\n"
-                    "Respond with only the intent name."
+                    "- 'generative' (creative writing, stories, poems, general knowledge questions, explanations, opinions, conversation)\n"
+                    "- 'tool_use' (calculations, storing/recalling personal data, API calls, running code, specific actions with measurable results)\n\n"
+                    "Important: Questions like 'What is X?' or 'Tell me about Y' are GENERATIVE - they need knowledge, not tools.\n"
+                    "Only use tool_use for things that require executing code or calling an API.\n\n"
+                    "Respond with ONLY the intent name, nothing else."
                 )
             },
             {"role": "user", "content": goal}

neural_engine/core/memory_operations_specialist.py

@@ -3,11 +3,16 @@
 
 This specialized classifier focuses ONLY on memory operations,
 achieving higher accuracy than the general classifier.
+
+Uses tool semantic metadata for action hints when available.
 """
 
-from typing import Dict
+from typing import Dict, Optional, TYPE_CHECKING
 from .neuron import BaseNeuron
 
+if TYPE_CHECKING:
+    from neural_engine.core.tool_discovery import ToolDiscovery
+
 
 class MemoryOperationsSpecialist(BaseNeuron):
     """
@@ -16,14 +21,54 @@ class MemoryOperationsSpecialist(BaseNeuron):
     Distinguishes between:
     - memory_write: Storing information
     - memory_read: Retrieving information
+    
+    Uses semantic metadata from tools when available.
     """
 
-    def __init__(self, message_bus, ollama_client):
+    def __init__(self, message_bus, ollama_client, tool_discovery: Optional['ToolDiscovery'] = None):
         super().__init__(message_bus, ollama_client)
+        self.tool_discovery = tool_discovery
+        
+        # Cache tool action hints (populated from semantic metadata)
+        self._write_actions = {"store", "save", "write", "remember", "memorize", "note"}
+        self._read_actions = {"retrieve", "recall", "get", "read", "fetch"}
+    
+    def set_tool_discovery(self, tool_discovery: 'ToolDiscovery'):
+        """Set tool discovery and update action hints from metadata."""
+        self.tool_discovery = tool_discovery
+        self._update_action_hints()
+    
+    def _update_action_hints(self):
+        """Update action hints from tool semantic metadata."""
+        if not self.tool_discovery:
+            return
+        
+        # Get memory tools and extract their action metadata
+        try:
+            tools = self.tool_discovery.tool_registry.get_all_tools()
+            
+            for tool_name, tool_instance in tools.items():
+                if hasattr(tool_instance, 'get_semantic_metadata'):
+                    metadata = tool_instance.get_semantic_metadata()
+                    if metadata.get('domain') == 'memory':
+                        actions = set(metadata.get('actions', []))
+                        synonyms = set(metadata.get('synonyms', []))
+                        
+                        # memory_write actions
+                        if 'store' in actions or 'save' in actions or 'write' in actions:
+                            self._write_actions.update(actions)
+                            self._write_actions.update(synonyms)
+                        
+                        # memory_read actions  
+                        if 'retrieve' in actions or 'read' in actions or 'get' in actions:
+                            self._read_actions.update(actions)
+                            self._read_actions.update(synonyms)
+        except Exception:
+            pass  # Keep defaults if tool discovery fails
 
     def classify_memory_operation(self, goal: str) -> str:
         """
-        Classify memory operation type.
+        Classify memory operation type using LLM with semantic-aware fallback.
         
         Args:
             goal: User goal text
@@ -43,19 +88,6 @@ def classify_memory_operation(self, goal: str) -> str:
                     "- Questions (What? Tell me? Recall?) → read\n"
                     "- Commands to store (Remember that X, Save Y) → write\n"
                     "- Past tense recall (what I told you, what you know) → read\n\n"
-                    "Examples:\n"
-                    "User: Remember that my name is Alice\n"
-                    "Assistant: write\n\n"
-                    "User: What is my name?\n"
-                    "Assistant: read\n\n"
-                    "User: Remember what I told you about my favorite color\n"
-                    "Assistant: read\n\n"
-                    "User: Store the value 42 for key 'answer'\n"
-                    "Assistant: write\n\n"
-                    "User: Recall what I told you about my birthday\n"
-                    "Assistant: read\n\n"
-                    "User: What did I tell you?\n"
-                    "Assistant: read\n\n"
                     "Respond with ONLY 'write' or 'read'."
                 )
             },
@@ -65,44 +97,40 @@ def classify_memory_operation(self, goal: str) -> str:
         response = self.ollama_client.chat(messages)
         operation = response['message']['content'].strip().lower()
 
-        # Fallback: analyze keywords FIRST before trusting LLM response
+        # Semantic-aware fallback using action hints from tool metadata
         goal_lower = goal.lower()
 
-        # Strongest WRITE signals - statements of fact with "my X is Y" pattern
-        if any(p in goal_lower for p in ["my name is", "my favorite", "i am", "i'm from", "i like", "i live", "actually"]):
-            # Check if it's a question (would be read)
-            if not any(q in goal_lower for q in ["what", "who", "when", "where", "why", "how", "tell me", "?", "recall"]):
-                return "write"
+        # Check if goal contains write actions (from semantic metadata)
+        write_action_score = sum(1 for action in self._write_actions if action in goal_lower)
+        read_action_score = sum(1 for action in self._read_actions if action in goal_lower)
 
-        # Strongest READ signals - past tense recall patterns
-        if any(p in goal_lower for p in ["what i told", "what i said", "what you know", "told you about", "said earlier", "remember what"]):
-            return "read"
+        # Linguistic patterns for read/write detection (grammatical, not domain-specific)
+        # These are OK because they detect SENTENCE STRUCTURE, not topic
+        is_statement = any(p in goal_lower for p in ["my name is", "my favorite is", "i am ", "i like "])
+        is_question = "?" in goal or any(q in goal_lower for q in ["what is", "who is", "tell me"])
+        is_recall = any(p in goal_lower for p in ["what i told", "what you know", "do you remember"])
 
-        # Question words strongly indicate read
-        if any(q in goal_lower for q in ["what is", "who is", "when did", "where is", "why did", "how did", "tell me", "show me", "recall"]):
+        # Combine signals
+        if is_statement and not is_question and not is_recall:
+            return "write"
+        
+        if is_question or is_recall:
             return "read"
 
-        # Validate and clean LLM response
-        if "write" in operation or "stor" in operation or "save" in operation:
+        # Use action scores from semantic metadata
+        if write_action_score > read_action_score:
             return "write"
-        elif "read" in operation or "recall" in operation or "get" in operation:
+        elif read_action_score > write_action_score:
             return "read"
-        else:
-            # Final fallback: check for explicit write commands
-            write_patterns = ["remember that", "store", "save", "write", "note that", "set"]
-            read_patterns = ["recall", "retrieve", "get", "fetch"]
-            
-            # Check for explicit write patterns with "that" clause
-            for pattern in write_patterns:
-                if pattern in goal_lower and "that" in goal_lower:
-                    return "write"
-            
-            # Check for read patterns
-            if any(p in goal_lower for p in read_patterns):
-                return "read"
-            
-            # Default to read if uncertain (safer - read has no side effects)
+        
+        # Trust LLM response as final fallback
+        if "write" in operation or "stor" in operation:
+            return "write"
+        elif "read" in operation or "recall" in operation:
             return "read"
+        
+        # Default to read (safer - no side effects)
+        return "read"
 
     def select_memory_tool(self, goal: str) -> Dict:
         """