fix: implement suggestions from scoschre on customizing run configuration

Author: Donato Azevedo

src/openapi-mcp-server/README.md

@@ -209,6 +209,13 @@ export SERVER_PORT=8000
 export SERVER_TRANSPORT="stdio"  # Option: stdio, streamable-http
 export LOG_LEVEL="INFO"  # Options: DEBUG, INFO, WARNING, ERROR, CRITICAL
 
+# HTTP transport configuration
+export TRANSPORT="stdio"  # Transport protocol: "stdio" (default) or "streamable-http"
+export MCP_PATH="/mcp"  # Path for MCP remote connection URL (only used with streamable-http)
+export STATELESS_HTTP="true"  # Enable stateless HTTP mode (only used with streamable-http)
+export JSON_RESPONSE="true"  # Use JSON responses instead of SSE stream (only used with streamable-http)
+export FASTMCP_LOG_LEVEL="INFO"  # FastMCP logging level: DEBUG, INFO, WARNING, ERROR, CRITICAL
+
 # Metrics and monitoring configuration
 export ENABLE_PROMETHEUS="false"  # Enable/disable Prometheus metrics (default: false)
 export PROMETHEUS_PORT=9090  # Port for Prometheus metrics server

src/openapi-mcp-server/awslabs/openapi_mcp_server/api/config.py

@@ -53,10 +53,16 @@ class Config:
     host: str = '127.0.0.1'
     port: int = 8000
     debug: bool = False
-    transport: str = 'stdio'  # stdio only
+    transport: str = 'stdio'  # stdio or streamable-http
     message_timeout: int = 60
     version: str = '0.2.0'
 
+    # HTTP transport configuration
+    mcp_path: str = '/mcp'
+    stateless_http: bool = True
+    json_response: bool = True
+    fastmcp_log_level: str = 'INFO'
+
 
 def load_config(args: Any = None) -> Config:
     """Load configuration from arguments and environment variables.
@@ -107,6 +113,12 @@ def load_config(args: Any = None) -> Config:
         'SERVER_DEBUG': (lambda v: setattr(config, 'debug', v.lower() == 'true')),
         'SERVER_TRANSPORT': (lambda v: setattr(config, 'transport', v)),
         'SERVER_MESSAGE_TIMEOUT': (lambda v: setattr(config, 'message_timeout', int(v))),
+        # HTTP transport configuration
+        'TRANSPORT': (lambda v: setattr(config, 'transport', v)),
+        'MCP_PATH': (lambda v: setattr(config, 'mcp_path', v)),
+        'STATELESS_HTTP': (lambda v: setattr(config, 'stateless_http', v.lower() == 'true')),
+        'JSON_RESPONSE': (lambda v: setattr(config, 'json_response', v.lower() == 'true')),
+        'FASTMCP_LOG_LEVEL': (lambda v: setattr(config, 'fastmcp_log_level', v)),
     }
 
     # Load environment variables
@@ -140,6 +152,10 @@ def load_config(args: Any = None) -> Config:
             logger.debug(f'Setting API spec path from arguments: {args.spec_path}')
             config.api_spec_path = args.spec_path
 
+        if hasattr(args, 'host') and args.host:
+            logger.debug(f'Setting host from arguments: {args.host}')
+            config.host = args.host
+
         if hasattr(args, 'port') and args.port:
             logger.debug(f'Setting port from arguments: {args.port}')
             config.port = args.port
@@ -148,6 +164,14 @@ def load_config(args: Any = None) -> Config:
             logger.debug('Setting debug mode from arguments')
             config.debug = True
 
+        if hasattr(args, 'transport') and args.transport:
+            logger.debug(f'Setting transport from arguments: {args.transport}')
+            config.transport = args.transport
+
+        if hasattr(args, 'mcp_path') and args.mcp_path:
+            logger.debug(f'Setting MCP path from arguments: {args.mcp_path}')
+            config.mcp_path = args.mcp_path
+
         # Authentication arguments
         if hasattr(args, 'auth_type') and args.auth_type:
             logger.debug(f'Setting auth type from arguments: {args.auth_type}')

src/openapi-mcp-server/awslabs/openapi_mcp_server/server.py

@@ -56,6 +56,7 @@ def create_mcp_server(config: Config) -> FastMCP:
     # Create the FastMCP server
     server = FastMCP(
         'awslabs.openapi-mcp-server',
+        json_response=config.json_response,
         instructions='This server acts as a bridge between OpenAPI specifications and LLMs, allowing models to have a better understanding of available API capabilities without requiring manual tool definitions.',
         dependencies=[
             'pydantic',
@@ -200,6 +201,7 @@ def handle_auth_error(auth_type, error_message):
             client=client,
             name=config.api_name or 'OpenAPI MCP Server',
             route_maps=custom_mappings,  # Custom mappings take precedence over default mappings
+            json_response=config.json_response,
         )
 
         # Log route information at debug level
@@ -450,6 +452,15 @@ def main():
         help='Comma-separated list of scopes for Cognito OAuth 2.0 client credentials flow',
     )
 
+    parser.add_argument(
+        '--transport',
+        help='Transport prototocol. stdio or streamable-http.',
+    )
+
+    parser.add_argument('--host', help='Server host (default: 127.0.0.1)')
+    parser.add_argument('--port', type=int, help='Server port (default: 8000)')
+    parser.add_argument('--mcp-path', help='The path for the mcp server (default: /mcp)')
+
     args = parser.parse_args()
 
     # Set up logging with loguru at specified level
@@ -512,12 +523,22 @@ async def get_all_counts(server):
         logger.error(f'Traceback: {traceback.format_exc()}')
         sys.exit(1)
 
+    run_params = {}
     if config.transport == 'streamable-http':
-        logger.info('Running server with streamable-http transport')
-        mcp_server.run(transport='streamable-http', stateless_http=True, host='0.0.0.0')
+        logger.info(
+            f'Starting OpenAPI-MCP-SERVER on {config.host}:{config.port} with transport=streamable-http...'
+        )
+        run_params = {
+            'host': config.host,
+            'port': config.port,
+            'path': config.mcp_path,
+            'stateless_http': config.stateless_http,
+            'log_level': config.fastmcp_log_level,
+        }
     else:
-        logger.info('Running server with stdio transport')
-        mcp_server.run()
+        logger.info('Starting OpenAPI-MCP-SERVER with transport=stdio...')
+
+    mcp_server.run(transport=config.transport, **run_params)
 
 
 if __name__ == '__main__':

src/openapi-mcp-server/tests/api/test_config_transport.py

@@ -0,0 +1,129 @@
+# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Tests for HTTP transport configuration."""
+
+import os
+import pytest
+from unittest.mock import patch
+from awslabs.openapi_mcp_server.api.config import Config, load_config
+
+
+class TestConfigTransport:
+    """Test Config HTTP transport settings."""
+
+    def test_default_config_values(self):
+        """Test that default config values are correct for HTTP transport."""
+        config = Config()
+        
+        # Test default transport settings
+        assert config.transport == 'stdio'
+        assert config.mcp_path == '/mcp'
+        assert config.stateless_http == True
+        assert config.json_response == True
+        assert config.fastmcp_log_level == 'INFO'
+
+    @patch.dict(
+        os.environ,
+        {
+            'TRANSPORT': 'streamable-http',
+            'MCP_PATH': '/custom-mcp',
+            'STATELESS_HTTP': 'false',
+            'JSON_RESPONSE': 'false',
+            'FASTMCP_LOG_LEVEL': 'DEBUG',
+        },
+        clear=True,
+    )
+    def test_env_var_overrides(self):
+        """Test that environment variables override default values."""
+        config = load_config()
+        
+        assert config.transport == 'streamable-http'
+        assert config.mcp_path == '/custom-mcp'
+        assert config.stateless_http == False
+        assert config.json_response == False
+        assert config.fastmcp_log_level == 'DEBUG'
+
+    @patch.dict(
+        os.environ,
+        {
+            'SERVER_HOST': '0.0.0.0',
+            'SERVER_PORT': '9000',
+            'TRANSPORT': 'streamable-http',
+        },
+        clear=True,
+    )
+    def test_existing_server_env_vars(self):
+        """Test that existing SERVER_HOST and SERVER_PORT work with new transport."""
+        config = load_config()
+        
+        assert config.host == '0.0.0.0'
+        assert config.port == 9000
+        assert config.transport == 'streamable-http'
+
+    @patch.dict(
+        os.environ,
+        {
+            'SERVER_TRANSPORT': 'streamable-http',
+            'TRANSPORT': 'stdio',
+        },
+        clear=True,
+    )
+    def test_both_transport_env_vars(self):
+        """Test that both SERVER_TRANSPORT and TRANSPORT can set transport."""
+        # TRANSPORT should take precedence as it's processed later
+        config = load_config()
+        
+        assert config.transport == 'stdio'
+
+    @patch.dict(os.environ, {'STATELESS_HTTP': 'invalid'}, clear=True)
+    def test_boolean_parsing(self):
+        """Test boolean environment variable parsing."""
+        config = load_config()
+        
+        # Invalid boolean should default to False
+        assert config.stateless_http == False
+
+    @patch.dict(os.environ, {'STATELESS_HTTP': 'TRUE'}, clear=True)
+    def test_boolean_parsing_case_insensitive(self):
+        """Test boolean parsing is case insensitive."""
+        config = load_config()
+        
+        assert config.stateless_http == True
+
+    def test_config_with_args(self):
+        """Test config loading with command line arguments."""
+        
+        class MockArgs:
+            def __init__(self):
+                self.api_name = 'test-api'
+                self.debug = True
+                self.host = '0.0.0.0'
+                self.port = 9999
+                self.transport = 'streamable-http'
+                self.mcp_path = '/custom-mcp'
+        
+        args = MockArgs()
+        config = load_config(args)
+
+        assert config.api_name == 'test-api'
+        assert config.debug == True
+        assert config.mcp_path == '/custom-mcp'
+        assert config.transport == 'streamable-http'
+        assert config.host == '0.0.0.0'
+        assert config.port == 9999
+
+        # HTTP transport settings should keep defaults
+        assert config.stateless_http == True
+        assert config.json_response == True
+        assert config.fastmcp_log_level == 'INFO'