changes followig CR

Author: DougieHauser

docs/03_advanced_usage.md

@@ -62,6 +62,13 @@ mcp = FastApiMCP(
     include_tags=["public"]
 )
 
+# Limit maximum allowed length for combined tool name (calculated as server name + operation_id)
+# Some vendors throw errors if combined tool names are too long
+mcp = FastApiMCP(
+    app,
+    max_tool_name_length=25,
+)
+
 mcp.mount()
 ```
 

fastapi_mcp/server.py

@@ -16,8 +16,6 @@
 
 logger = logging.getLogger(__name__)
 
-FULL_TOOL_NAME_MAX_LENGTH = 55
-
 
 class FastApiMCP:
     def __init__(
@@ -40,6 +38,7 @@ def __init__(
         exclude_operations: Optional[List[str]] = None,
         include_tags: Optional[List[str]] = None,
         exclude_tags: Optional[List[str]] = None,
+        max_tool_name_length: Optional[int] = None,
     ):
         """
         Create an MCP server from a FastAPI app.
@@ -54,6 +53,8 @@ def __init__(
             exclude_operations: List of operation IDs to exclude from MCP tools. Cannot be used with include_operations.
             include_tags: List of tags to include as MCP tools. Cannot be used with exclude_tags.
             exclude_tags: List of tags to exclude from MCP tools. Cannot be used with include_tags.
+            max_tool_name_length: Maximum length allowed for tools (some vendors prohibit long names).
+                Tools breaching this restriction will be filtered out.
         """
         # Validate operation and tag filtering options
         if include_operations is not None and exclude_operations is not None:
@@ -77,6 +78,7 @@ def __init__(
         self._exclude_operations = exclude_operations
         self._include_tags = include_tags
         self._exclude_tags = exclude_tags
+        self._max_tool_name_length = max_tool_name_length
 
         self._http_client = http_client or httpx.AsyncClient(
             transport=httpx.ASGITransport(app=self.fastapi, raise_app_exceptions=False),
@@ -322,6 +324,7 @@ def _filter_tools(self, tools: List[types.Tool], openapi_schema: Dict[str, Any])
             and self._exclude_operations is None
             and self._include_tags is None
             and self._exclude_tags is None
+            and self._max_tool_name_length is None
         ):
             return tools
 
@@ -339,23 +342,6 @@ def _filter_tools(self, tools: List[types.Tool], openapi_schema: Dict[str, Any])
                     )
                     continue
 
-                operation_full_name = self.get_tool_full_name(operation_id)
-                if len(operation_full_name) > FULL_TOOL_NAME_MAX_LENGTH:
-                    logger.warning(f"Skipping operation with exceedingly long operationId: {operation_full_name}")
-                    continue
-
-                """
-                if method not in ["get", "post", "put", "delete", "patch"]:
-                logger.warning(f"Skipping non-HTTP method: {method.upper()} {path}")
-                continue
-
-            # Get operation metadata
-            operation_id = operation.get("operationId")
-            if not operation_id:
-                logger.warning(f"Skipping operation with no operationId: {method.upper()} {path}, details: {operation}")
-                continue
-                """
-
                 tags = operation.get("tags", [])
                 for tag in tags:
                     if tag not in operations_by_tag:
@@ -364,11 +350,14 @@ def _filter_tools(self, tools: List[types.Tool], openapi_schema: Dict[str, Any])
 
         operations_to_include = set()
 
+        all_operations = {tool.name for tool in tools}
+
         if self._include_operations is not None:
             operations_to_include.update(self._include_operations)
         elif self._exclude_operations is not None:
-            all_operations = {tool.name for tool in tools}
             operations_to_include.update(all_operations - set(self._exclude_operations))
+        elif self._max_tool_name_length is not None:
+            operations_to_include.update(all_operations)  # all_operations
 
         if self._include_tags is not None:
             for tag in self._include_tags:
@@ -378,9 +367,14 @@ def _filter_tools(self, tools: List[types.Tool], openapi_schema: Dict[str, Any])
             for tag in self._exclude_tags:
                 excluded_operations.update(operations_by_tag.get(tag, []))
 
-            all_operations = {tool.name for tool in tools}
             operations_to_include.update(all_operations - excluded_operations)
 
+        if self._max_tool_name_length is not None:
+            long_operations = {
+                tool.name for tool in tools if len(self.get_combined_full_name(tool.name)) > self._max_tool_name_length
+            }
+            operations_to_include = operations_to_include - long_operations
+
         filtered_tools = [tool for tool in tools if tool.name in operations_to_include]
 
         if filtered_tools:
@@ -391,5 +385,17 @@ def _filter_tools(self, tools: List[types.Tool], openapi_schema: Dict[str, Any])
 
         return filtered_tools
 
-    def get_tool_full_name(self, operation_id: str) -> str:
+    def get_combined_full_name(self, operation_id: str) -> str:
+        """
+        Combined name consists of server name + operation_id
+
+        Args:
+            operation_id: As defined during creation
+
+        Returns:
+            concatenated string of server name + operation_id
+        """
+        if not self.name:
+            return operation_id
+
         return f"{self.name}\\{operation_id}"

tests/test_configuration.py

@@ -17,6 +17,8 @@ def test_default_configuration(simple_fastapi_app: FastAPI):
     assert mcp_server._describe_all_responses is False
     assert mcp_server._describe_full_response_schema is False
 
+    assert mcp_server._max_tool_name_length is None
+
 
 def test_custom_configuration(simple_fastapi_app: FastAPI):
     """Test a custom configuration of FastApiMCP."""
@@ -372,13 +374,21 @@ async def delete_item(item_id: int):
     async def search_items():
         return [{"id": 1}]
 
+    @app.get("/long_search/", operation_id="search_items_long_id", tags=["search"])
+    async def search_items_long():
+        return [{"id": 1}]
+
+    # benchmark - no filter
+    no_filter = FastApiMCP(app)
+    assert len(no_filter.tools) == 7
+
     # Test include_operations
     include_ops_mcp = FastApiMCP(app, include_operations=["get_item", "list_items"])
     assert len(include_ops_mcp.tools) == 2
     assert {tool.name for tool in include_ops_mcp.tools} == {"get_item", "list_items"}
 
     # Test exclude_operations
-    exclude_ops_mcp = FastApiMCP(app, exclude_operations=["delete_item", "search_items"])
+    exclude_ops_mcp = FastApiMCP(app, exclude_operations=["delete_item", "search_items", "search_items_long_id"])
     assert len(exclude_ops_mcp.tools) == 4
     assert {tool.name for tool in exclude_ops_mcp.tools} == {"get_item", "list_items", "create_item", "update_item"}
 
@@ -389,13 +399,21 @@ async def search_items():
 
     # Test exclude_tags
     exclude_tags_mcp = FastApiMCP(app, exclude_tags=["write", "delete"])
-    assert len(exclude_tags_mcp.tools) == 3
-    assert {tool.name for tool in exclude_tags_mcp.tools} == {"get_item", "list_items", "search_items"}
+    assert len(exclude_tags_mcp.tools) == 4
+    assert {tool.name for tool in exclude_tags_mcp.tools} == {
+        "get_item",
+        "list_items",
+        "search_items",
+        "search_items_long_id",
+    }
 
     # Test combining include_operations and include_tags
     combined_include_mcp = FastApiMCP(app, include_operations=["delete_item"], include_tags=["search"])
-    assert len(combined_include_mcp.tools) == 2
-    assert {tool.name for tool in combined_include_mcp.tools} == {"delete_item", "search_items"}
+    assert len(combined_include_mcp.tools) == 3
+    assert {tool.name for tool in combined_include_mcp.tools} == {"delete_item", "search_items", "search_items_long_id"}
+
+    max_long_name_mcp = FastApiMCP(app, name="mcp_server", max_tool_name_length=25)
+    assert len(max_long_name_mcp.tools) == 6
 
     # Test invalid combinations
     with pytest.raises(ValueError):