rootly-mcp-server 2.0.11__tar.gz → 2.0.12__tar.gz

{rootly_mcp_server-2.0.11 → rootly_mcp_server-2.0.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rootly-mcp-server
-Version: 2.0.11
+Version: 2.0.12
 Summary: A Model Context Protocol server for Rootly APIs using OpenAPI spec
 Project-URL: Homepage, https://github.com/Rootly-AI-Labs/Rootly-MCP-server
 Project-URL: Issues, https://github.com/Rootly-AI-Labs/Rootly-MCP-server/issues

{rootly_mcp_server-2.0.11 → rootly_mcp_server-2.0.12}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "rootly-mcp-server"
-version = "2.0.11"
+version = "2.0.12"
 description = "A Model Context Protocol server for Rootly APIs using OpenAPI spec"
 readme = "README.md"
 requires-python = ">=3.12"

{rootly_mcp_server-2.0.11 → rootly_mcp_server-2.0.12}/src/rootly_mcp_server/__init__.py

@@ -13,7 +13,7 @@ Features:
 from .server import RootlyMCPServer
 from .client import RootlyClient
 
-__version__ = "2.0.1"
+__version__ = "2.0.12"
 __all__ = [
     'RootlyMCPServer',
     'RootlyClient',

{rootly_mcp_server-2.0.11 → rootly_mcp_server-2.0.12}/src/rootly_mcp_server/smart_utils.py

@@ -13,10 +13,13 @@ from datetime import datetime
 
 # Check ML library availability
 import importlib.util
-ML_AVAILABLE = (
-    importlib.util.find_spec("sklearn.feature_extraction.text") is not None and
-    importlib.util.find_spec("sklearn.metrics.pairwise") is not None
-)
+try:
+    ML_AVAILABLE = (
+        importlib.util.find_spec("sklearn.feature_extraction.text") is not None and
+        importlib.util.find_spec("sklearn.metrics.pairwise") is not None
+    )
+except (ImportError, ModuleNotFoundError):
+    ML_AVAILABLE = False
 
 logger = logging.getLogger(__name__)
 
@@ -73,13 +76,27 @@ class TextSimilarityAnalyzer:
             r'\b(\w+)-(?:service|api|app|server|db)\b',  # service-api, auth-service
             r'\b(\w+)(?:service|api|app|server|db)\b',   # paymentapi, authservice
             r'\b(\w+)\.(?:service|api|app|com)\b',       # auth.service, api.com
+            r'\b(\w+)\s+(?:api|service|app|server|db)\b',  # payment api, auth service
+        ]
+        
+        # Known service names (exact matches)
+        known_services = [
+            'elasticsearch', 'elastic', 'kibana', 'redis', 'postgres', 'mysql', 
+            'mongodb', 'kafka', 'rabbitmq', 'nginx', 'apache', 'docker', 'kubernetes'
         ]
         
         text_lower = text.lower()
+        
+        # Extract pattern-based services
         for pattern in service_patterns:
             matches = re.findall(pattern, text_lower)
             services.extend(matches)
         
+        # Extract known services (with word boundaries to avoid false positives)
+        for service in known_services:
+            if re.search(r'\b' + re.escape(service) + r'\b', text_lower):
+                services.append(service)
+        
         # Remove duplicates while preserving order
         return list(dict.fromkeys(services))
     
@@ -128,18 +145,26 @@ class TextSimilarityAnalyzer:
         """Combine incident title, description, and other text fields."""
         text_parts = []
         
-        # Get text from incident attributes
+        # Get text from incident attributes (preferred)
         attributes = incident.get('attributes', {})
-        text_parts.append(attributes.get('title', ''))
-        text_parts.append(attributes.get('summary', ''))
-        text_parts.append(attributes.get('description', ''))
-        
-        # Also check root level for backward compatibility
-        text_parts.append(incident.get('title', ''))
-        text_parts.append(incident.get('summary', ''))
-        text_parts.append(incident.get('description', ''))
-        
-        combined = ' '.join([part for part in text_parts if part])
+        title = attributes.get('title', '')
+        summary = attributes.get('summary', '')
+        description = attributes.get('description', '')
+        
+        # Fallback to root level if attributes are empty
+        if not title:
+            title = incident.get('title', '')
+        if not summary:
+            summary = incident.get('summary', '')
+        if not description:
+            description = incident.get('description', '')
+        
+        # Add non-empty parts, avoiding duplication
+        for part in [title, summary, description]:
+            if part and part not in text_parts:
+                text_parts.append(part)
+        
+        combined = ' '.join(text_parts)
         return self.preprocess_text(combined)
     
     def _calculate_tfidf_similarity(self, incidents: List[Dict], target_incident: Dict, 
@@ -175,7 +200,15 @@ class TextSimilarityAnalyzer:
                 service_bonus = len(set(target_services) & set(incident_services)) * 0.1
                 error_bonus = len(set(target_errors) & set(incident_errors)) * 0.15
                 
-                final_score = min(1.0, similarities[i] + service_bonus + error_bonus)
+                # Exact match bonus for identical preprocessed text
+                exact_match_bonus = 0.0
+                if target_text and incident_texts[i] and target_text.strip() == incident_texts[i].strip():
+                    exact_match_bonus = 0.3  # Strong bonus for exact matches
+                
+                # Partial matching bonus using fuzzy keyword similarity
+                partial_bonus = self._calculate_partial_similarity_bonus(target_text, incident_texts[i])
+                
+                final_score = min(1.0, similarities[i] + service_bonus + error_bonus + exact_match_bonus + partial_bonus)
                 
                 results.append(IncidentSimilarity(
                     incident_id=str(incident.get('id', '')),
@@ -212,7 +245,15 @@ class TextSimilarityAnalyzer:
             service_bonus = len(set(target_services) & set(incident_services)) * 0.2
             error_bonus = len(set(target_errors) & set(incident_errors)) * 0.25
             
-            final_score = min(1.0, word_similarity + service_bonus + error_bonus)
+            # Exact match bonus for identical preprocessed text
+            exact_match_bonus = 0.0
+            if target_text and incident_text and target_text.strip() == incident_text.strip():
+                exact_match_bonus = 0.4  # Strong bonus for exact matches in keyword mode
+            
+            # Partial matching bonus using fuzzy keyword similarity
+            partial_bonus = self._calculate_partial_similarity_bonus(target_text, incident_text)
+            
+            final_score = min(1.0, word_similarity + service_bonus + error_bonus + exact_match_bonus + partial_bonus)
             
             if final_score > 0.15:  # Only include reasonable matches
                 results.append(IncidentSimilarity(
@@ -228,14 +269,94 @@ class TextSimilarityAnalyzer:
         return results
     
     def _extract_common_keywords(self, text1: str, text2: str) -> List[str]:
-        """Extract common meaningful keywords between two texts."""
+        """Extract common meaningful keywords between two texts with fuzzy matching."""
+        words1 = set(text1.split())
+        words2 = set(text2.split())
+        
+        # Exact matches
+        exact_common = words1 & words2
+        
+        # Fuzzy matches for partial similarity
+        fuzzy_common = []
+        for word1 in words1:
+            if len(word1) > 3:  # Only check longer words
+                for word2 in words2:
+                    if len(word2) > 3 and word1 != word2:
+                        # Check if words share significant substring (fuzzy matching)
+                        if self._words_similar(word1, word2):
+                            fuzzy_common.append(f"{word1}~{word2}")
+        
+        # Combine exact and fuzzy matches
+        all_matches = list(exact_common) + fuzzy_common
+        meaningful = [word for word in all_matches if len(word.split('~')[0]) > 2]
+        return meaningful[:8]  # Increased to show more matches
+    
+    def _words_similar(self, word1: str, word2: str) -> bool:
+        """Check if two words are similar enough to be considered related."""
+        # Handle common variations
+        variations = {
+            'elastic': ['elasticsearch', 'elk'],
+            'payment': ['payments', 'pay', 'billing'],
+            'database': ['db', 'postgres', 'mysql', 'mongo'],
+            'timeout': ['timeouts', 'timed-out', 'timing-out'],
+            'service': ['services', 'svc', 'api', 'app'],
+            'error': ['errors', 'err', 'failure', 'failed', 'failing'],
+            'down': ['outage', 'offline', 'unavailable']
+        }
+        
+        # Check if words are variations of each other
+        for base, variants in variations.items():
+            if (word1 == base and word2 in variants) or (word2 == base and word1 in variants):
+                return True
+            if word1 in variants and word2 in variants:
+                return True
+        
+        # Check substring similarity (at least 70% overlap for longer words)
+        if len(word1) >= 5 and len(word2) >= 5:
+            shorter = min(word1, word2, key=len)
+            longer = max(word1, word2, key=len)
+            if shorter in longer and len(shorter) / len(longer) >= 0.7:
+                return True
+        
+        # Check if one word starts with the other (for prefixed services)
+        if len(word1) >= 4 and len(word2) >= 4:
+            if word1.startswith(word2) or word2.startswith(word1):
+                return True
+                
+        return False
+    
+    def _calculate_partial_similarity_bonus(self, text1: str, text2: str) -> float:
+        """Calculate bonus for partial/fuzzy keyword matches."""
+        if not text1 or not text2:
+            return 0.0
+            
         words1 = set(text1.split())
         words2 = set(text2.split())
-        common = words1 & words2
         
-        # Filter out very short words and return top matches
-        meaningful = [word for word in common if len(word) > 2]
-        return meaningful[:5]
+        fuzzy_matches = 0
+        
+        # Count meaningful words that could be compared
+        meaningful_words1 = [w for w in words1 if len(w) > 3]
+        meaningful_words2 = [w for w in words2 if len(w) > 3]
+        
+        if not meaningful_words1 or not meaningful_words2:
+            return 0.0
+        
+        # Count fuzzy matches
+        for word1 in meaningful_words1:
+            for word2 in meaningful_words2:
+                if word1 != word2 and self._words_similar(word1, word2):
+                    fuzzy_matches += 1
+                    break  # Only count each target word once
+        
+        # Calculate bonus based on fuzzy match ratio
+        if fuzzy_matches > 0:
+            # Use the smaller meaningful word set as denominator for conservative bonus
+            total_possible_matches = min(len(meaningful_words1), len(meaningful_words2))
+            bonus_ratio = fuzzy_matches / total_possible_matches
+            return min(0.15, bonus_ratio * 0.3)  # Max 0.15 bonus for partial matches
+        
+        return 0.0
     
     def _calculate_resolution_time(self, incident: Dict) -> Optional[float]:
         """Calculate resolution time in hours if timestamps are available."""

{rootly_mcp_server-2.0.11 → rootly_mcp_server-2.0.12}/tests/integration/local/test_smart_tools.py

@@ -107,10 +107,14 @@ class TestSmartToolsIntegration:
         payment_incidents = [inc for inc in similar_incidents if "payment" in inc.title.lower()]
         assert len(payment_incidents) >= 2  # Should find both payment incidents
         
-        # Check that similarity scores are reasonable
+        # Check that similarity scores are reasonable (updated for partial matching bonuses)
         top_incident = similar_incidents[0]
         assert top_incident.similarity_score > 0.1
         assert top_incident.incident_id in ["1001", "1003"]  # Should be a payment incident
+        
+        # Check that matched services are detected
+        payment_matches = [inc for inc in similar_incidents if "payment" in inc.matched_services]
+        assert len(payment_matches) > 0  # Should detect payment service matches
     
     async def test_suggest_solutions_with_incident_id(self, server_with_smart_tools, mock_target_incident, mock_historical_incidents):
         """Test solution suggestions using incident ID."""
@@ -250,7 +254,9 @@ class TestSmartToolsIntegration:
             ("authapi connection failed", ["auth"]),
             ("user.service timeout", ["user"]),
             ("Error in notification-api and billing-service", ["notification", "billing"]),
-            ("postgres-db connection issue", ["postgres"])
+            ("postgres-db connection issue", ["postgres"]),
+            ("elasticsearch cluster failing", ["elasticsearch"]),  # New test for known services
+            ("elastic search timeout", ["elastic"]),  # Test partial matching
         ]
         
         for text, expected_services in test_cases:
@@ -258,4 +264,65 @@ class TestSmartToolsIntegration:
             
             for expected_service in expected_services:
                 assert expected_service in services, \
-                    f"Expected service '{expected_service}' not found in {services} for text '{text}'"
+                    f"Expected service '{expected_service}' not found in {services} for text '{text}'"
+    
+    def test_partial_matching_improvements(self):
+        """Test partial/fuzzy matching for related but not identical incidents."""
+        from rootly_mcp_server.smart_utils import TextSimilarityAnalyzer
+        
+        analyzer = TextSimilarityAnalyzer()
+        
+        # Test cases for partial matching
+        target_incident = {
+            "id": "target",
+            "attributes": {
+                "title": "Payment API timeout errors",
+                "summary": "Users experiencing payment failures due to API timeouts"
+            }
+        }
+        
+        historical_incidents = [
+            {
+                "id": "similar1", 
+                "attributes": {
+                    "title": "Payment service timeouts",
+                    "summary": "Payments API timing out for users"
+                }
+            },
+            {
+                "id": "similar2",
+                "attributes": {
+                    "title": "Billing API errors", 
+                    "summary": "Users unable to complete payments due to errors"
+                }
+            },
+            {
+                "id": "unrelated",
+                "attributes": {
+                    "title": "Auth service down",
+                    "summary": "Login failures for all users"
+                }
+            }
+        ]
+        
+        similar_incidents = analyzer.calculate_similarity(historical_incidents, target_incident)
+        
+        # Should find payment-related incidents with partial matching
+        payment_related = [inc for inc in similar_incidents 
+                          if inc.incident_id in ["similar1", "similar2"]]
+        auth_related = [inc for inc in similar_incidents 
+                       if inc.incident_id == "unrelated"]
+        
+        # Payment incidents should have higher scores than auth incident
+        if payment_related and auth_related:
+            max_payment_score = max(inc.similarity_score for inc in payment_related)
+            max_auth_score = max(inc.similarity_score for inc in auth_related)
+            assert max_payment_score > max_auth_score, \
+                f"Payment similarity ({max_payment_score}) should be higher than auth ({max_auth_score})"
+        
+        # Check that fuzzy keywords are detected
+        if payment_related:
+            top_match = max(payment_related, key=lambda x: x.similarity_score)
+            # Should detect partial matches like "payment~payments" or "timeout~timeouts"
+            # Note: This might be 0 if exact matches exist, which is also valid
+            assert top_match.similarity_score > 0.1, "Should have reasonable similarity score for payment incidents"

{rootly_mcp_server-2.0.11 → rootly_mcp_server-2.0.12}/tests/unit/test_smart_utils.py

@@ -247,7 +247,7 @@ class TestTextSimilarityAnalyzer:
         assert "timeout" in common  
         assert "error" in common
         assert "service" in common
-        assert len(common) <= 5  # Should limit to top 5
+        assert len(common) <= 8  # Should limit to top 8 (increased for fuzzy matching)
 
 
 class TestSolutionExtractor: