rootly-mcp-server 2.0.11__py3-none-any.whl → 2.0.13__py3-none-any.whl

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/server.py

@@ -391,7 +391,7 @@ def create_rootly_mcp_server(
         # Single page mode
         if page_number > 0:
             params = {
-                "page[size]": min(page_size, 5),  # Keep responses very small to avoid errors
+                "page[size]": page_size,  # Use requested page size (already limited to max 20)
                 "page[number]": page_number,
                 "include": "",
             }
@@ -409,7 +409,7 @@ def create_rootly_mcp_server(
         # Multi-page mode (page_number = 0)
         all_incidents = []
         current_page = 1
-        effective_page_size = min(page_size, 5)  # Keep responses very small to avoid errors
+        effective_page_size = page_size  # Use requested page size (already limited to max 20)
         max_pages = 10  # Safety limit to prevent infinite loops
 
         try:
@@ -922,6 +922,73 @@ def _filter_openapi_spec(spec: Dict[str, Any], allowed_paths: List[str]) -> Dict
                                 "description": param.get("description", "Parameter value")
                             }
 
+            # Add/modify pagination limits to alerts and incident-related endpoints to prevent infinite loops
+            if method.lower() == "get" and ("alerts" in path.lower() or "incident" in path.lower()):
+                if "parameters" not in operation:
+                    operation["parameters"] = []
+                
+                # Find existing pagination parameters and update them with limits
+                page_size_param = None
+                page_number_param = None
+                
+                for param in operation["parameters"]:
+                    if param.get("name") == "page[size]":
+                        page_size_param = param
+                    elif param.get("name") == "page[number]":
+                        page_number_param = param
+                
+                # Update or add page[size] parameter with limits
+                if page_size_param:
+                    # Update existing parameter with limits
+                    if "schema" not in page_size_param:
+                        page_size_param["schema"] = {}
+                    page_size_param["schema"].update({
+                        "type": "integer",
+                        "default": 10,
+                        "minimum": 1,
+                        "maximum": 20,
+                        "description": "Number of results per page (max: 20)"
+                    })
+                else:
+                    # Add new parameter
+                    operation["parameters"].append({
+                        "name": "page[size]",
+                        "in": "query",
+                        "required": False,
+                        "schema": {
+                            "type": "integer",
+                            "default": 10,
+                            "minimum": 1,
+                            "maximum": 20,
+                            "description": "Number of results per page (max: 20)"
+                        }
+                    })
+                
+                # Update or add page[number] parameter with defaults
+                if page_number_param:
+                    # Update existing parameter 
+                    if "schema" not in page_number_param:
+                        page_number_param["schema"] = {}
+                    page_number_param["schema"].update({
+                        "type": "integer",
+                        "default": 1,
+                        "minimum": 1,
+                        "description": "Page number to retrieve"
+                    })
+                else:
+                    # Add new parameter
+                    operation["parameters"].append({
+                        "name": "page[number]",
+                        "in": "query", 
+                        "required": False,
+                        "schema": {
+                            "type": "integer",
+                            "default": 1,
+                            "minimum": 1,
+                            "description": "Page number to retrieve"
+                        }
+                    })
+
     # Also clean up any remaining broken references in components
     if "components" in filtered_spec and "schemas" in filtered_spec["components"]:
         schemas = filtered_spec["components"]["schemas"]

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.dist-info → rootly_mcp_server-2.0.13.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rootly-mcp-server
-Version: 2.0.11
+Version: 2.0.13
 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.13.dist-info/RECORD

@@ -0,0 +1,12 @@
+rootly_mcp_server/__init__.py,sha256=rvIuqIyuzgC7b9qSnylrdDP2zPO-7Ou9AoblR6re1co,629
+rootly_mcp_server/__main__.py,sha256=_F4p65_VjnN84RtmEdESVLLH0tO5tL9qBfb2Xdvbj2E,6480
+rootly_mcp_server/client.py,sha256=uit-YijR7OAJtysBoclqnublEDVkFfcb29wSzhpBv44,4686
+rootly_mcp_server/server.py,sha256=BX4bRTlzUBI0xNha-owy9FRSmBCpVRM2qgSv5m5SHzE,44413
+rootly_mcp_server/smart_utils.py,sha256=lvGN9ITyJjBkm7ejpYagd8VWodLKnC6FmwECfCOcGwM,22973
+rootly_mcp_server/utils.py,sha256=NyxdcDiFGlV2a8eBO4lKgZg0D7Gxr6xUIB0YyJGgpPA,4165
+rootly_mcp_server/data/__init__.py,sha256=fO8a0bQnRVEoRMHKvhFzj10bhoaw7VsI51czc2MsUm4,143
+rootly_mcp_server-2.0.13.dist-info/METADATA,sha256=86--37XF6dDVqGyzqdmNGbaq0gEzRtGC_gJrtoduQXY,8722
+rootly_mcp_server-2.0.13.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+rootly_mcp_server-2.0.13.dist-info/entry_points.txt,sha256=NE33b8VgigVPGBkboyo6pvN1Vz35HZtLybxMO4Q03PI,70
+rootly_mcp_server-2.0.13.dist-info/licenses/LICENSE,sha256=c9w9ZZGl14r54tsP40oaq5adTVX_HMNHozPIH2ymzmw,11341
+rootly_mcp_server-2.0.13.dist-info/RECORD,,

rootly_mcp_server-2.0.11.dist-info/RECORD

@@ -1,12 +0,0 @@
-rootly_mcp_server/__init__.py,sha256=6pLh19IFyqE-Cve9zergkD-X_yApEkInREKmRa73T6s,628
-rootly_mcp_server/__main__.py,sha256=_F4p65_VjnN84RtmEdESVLLH0tO5tL9qBfb2Xdvbj2E,6480
-rootly_mcp_server/client.py,sha256=uit-YijR7OAJtysBoclqnublEDVkFfcb29wSzhpBv44,4686
-rootly_mcp_server/server.py,sha256=5NyGWUOjz1C1kFbAbu2iMNfuKo53_Sq254vF0cEUSHE,41358
-rootly_mcp_server/smart_utils.py,sha256=B0to9o55PMwQPLFT6GZAg_S_Nt4pKFRQq0AXBL-GJp8,17442
-rootly_mcp_server/utils.py,sha256=NyxdcDiFGlV2a8eBO4lKgZg0D7Gxr6xUIB0YyJGgpPA,4165
-rootly_mcp_server/data/__init__.py,sha256=fO8a0bQnRVEoRMHKvhFzj10bhoaw7VsI51czc2MsUm4,143
-rootly_mcp_server-2.0.11.dist-info/METADATA,sha256=fGFaM6E_5DJ1gdvFfuw1yyNBeJZMLdsDM56gRnDhy38,8722
-rootly_mcp_server-2.0.11.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-rootly_mcp_server-2.0.11.dist-info/entry_points.txt,sha256=NE33b8VgigVPGBkboyo6pvN1Vz35HZtLybxMO4Q03PI,70
-rootly_mcp_server-2.0.11.dist-info/licenses/LICENSE,sha256=c9w9ZZGl14r54tsP40oaq5adTVX_HMNHozPIH2ymzmw,11341
-rootly_mcp_server-2.0.11.dist-info/RECORD,,