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

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

@@ -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.11 → rootly_mcp_server-2.0.13}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "rootly-mcp-server"
-version = "2.0.11"
+version = "2.0.13"
 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.13}/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.13}/src/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-2.0.11 → rootly_mcp_server-2.0.13}/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.13}/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.13}/tests/unit/test_server.py

@@ -237,6 +237,19 @@ class TestOpenAPISpecFiltering:
         assert "/teams" in filtered_spec["paths"]
         assert "/forbidden" not in filtered_spec["paths"]
         
+        # Verify pagination parameters were added to /incidents endpoint
+        incidents_get = filtered_spec["paths"]["/incidents"]["get"]
+        assert "parameters" in incidents_get
+        param_names = [p["name"] for p in incidents_get["parameters"]]
+        assert "page[size]" in param_names
+        assert "page[number]" in param_names
+        
+        # Verify /teams endpoint does not get pagination (doesn't contain "incidents" or "alerts")
+        teams_get = filtered_spec["paths"]["/teams"]["get"]
+        if "parameters" in teams_get:
+            param_names = [p["name"] for p in teams_get["parameters"]]
+            assert "page[size]" not in param_names
+        
         # Verify other properties are preserved
         assert filtered_spec["openapi"] == original_spec["openapi"]
         assert filtered_spec["info"] == original_spec["info"]
@@ -276,6 +289,83 @@ class TestOpenAPISpecFiltering:
         assert "servers" in filtered_spec
         assert "components" in filtered_spec
         assert filtered_spec["servers"] == original_spec["servers"]
+        
+        # Verify pagination parameters were added to /incidents endpoint
+        incidents_get = filtered_spec["paths"]["/incidents"]["get"]
+        assert "parameters" in incidents_get
+        param_names = [p["name"] for p in incidents_get["parameters"]]
+        assert "page[size]" in param_names
+        assert "page[number]" in param_names
+
+    def test_filter_spec_adds_pagination_to_alerts(self):
+        """Test that pagination parameters are added to alerts endpoints."""
+        original_spec = {
+            "openapi": "3.0.0",
+            "info": {"title": "Test API", "version": "1.0.0"},
+            "paths": {
+                "/alerts": {"get": {"operationId": "listAlerts"}},
+                "/incidents/123/alerts": {"get": {"operationId": "listIncidentAlerts"}},
+                "/users": {"get": {"operationId": "listUsers"}},
+            },
+            "components": {"schemas": {}}
+        }
+        
+        allowed_paths = ["/alerts", "/incidents/123/alerts", "/users"]
+        filtered_spec = _filter_openapi_spec(original_spec, allowed_paths)
+        
+        # Verify pagination was added to alerts endpoints
+        alerts_get = filtered_spec["paths"]["/alerts"]["get"]
+        assert "parameters" in alerts_get
+        param_names = [p["name"] for p in alerts_get["parameters"]]
+        assert "page[size]" in param_names
+        assert "page[number]" in param_names
+        
+        incident_alerts_get = filtered_spec["paths"]["/incidents/123/alerts"]["get"]
+        assert "parameters" in incident_alerts_get
+        param_names = [p["name"] for p in incident_alerts_get["parameters"]]
+        assert "page[size]" in param_names
+        assert "page[number]" in param_names
+        
+        # Verify pagination was NOT added to /users (no "incident" or "alerts" in path)
+        users_get = filtered_spec["paths"]["/users"]["get"]
+        if "parameters" in users_get:
+            param_names = [p["name"] for p in users_get["parameters"]]
+            assert "page[size]" not in param_names
+
+    def test_filter_spec_adds_pagination_to_incident_types(self):
+        """Test that pagination parameters are added to incident-related endpoints."""
+        original_spec = {
+            "openapi": "3.0.0",
+            "info": {"title": "Test API", "version": "1.0.0"},
+            "paths": {
+                "/incident_types": {"get": {"operationId": "listIncidentTypes"}},
+                "/incident_action_items": {"get": {"operationId": "listIncidentActionItems"}},
+                "/services": {"get": {"operationId": "listServices"}},
+            },
+            "components": {"schemas": {}}
+        }
+        
+        allowed_paths = ["/incident_types", "/incident_action_items", "/services"]
+        filtered_spec = _filter_openapi_spec(original_spec, allowed_paths)
+        
+        # Verify pagination was added to incident-related endpoints
+        incident_types_get = filtered_spec["paths"]["/incident_types"]["get"]
+        assert "parameters" in incident_types_get
+        param_names = [p["name"] for p in incident_types_get["parameters"]]
+        assert "page[size]" in param_names
+        assert "page[number]" in param_names
+        
+        incident_action_items_get = filtered_spec["paths"]["/incident_action_items"]["get"]
+        assert "parameters" in incident_action_items_get
+        param_names = [p["name"] for p in incident_action_items_get["parameters"]]
+        assert "page[size]" in param_names
+        assert "page[number]" in param_names
+        
+        # Verify pagination was NOT added to /services (no "incident" or "alerts" in path)
+        services_get = filtered_spec["paths"]["/services"]["get"]
+        if "parameters" in services_get:
+            param_names = [p["name"] for p in services_get["parameters"]]
+            assert "page[size]" not in param_names
 
 
 @pytest.mark.unit

{rootly_mcp_server-2.0.11 → rootly_mcp_server-2.0.13}/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:

{rootly_mcp_server-2.0.11 → rootly_mcp_server-2.0.13}/uv.lock

@@ -873,7 +873,7 @@ wheels = [
 
 [[package]]
 name = "rootly-mcp-server"
-version = "2.0.10"
+version = "2.0.12"
 source = { editable = "." }
 dependencies = [
     { name = "brotli" },