# In mcpgateway/config.py class Settings(BaseSettings): # ... existing settings ... # Feature Flags - MCP Capabilities # These control which endpoints/features are enabled features_tools_enabled: bool = True features_resources_enabled: bool = False features_prompts_enabled: bool = False features_servers_enabled: bool = True features_gateways_enabled: bool = True features_roots_enabled: bool = False # Feature Flags - Additional Features  features_tags_enabled: bool = True # /tags endpoint features_reverse_proxy_enabled: bool = False # reverse proxy functionality features_rest_api_tools_enabled: bool = True # REST API to MCP Tools conversion (future/not implemented) features_metrics_enabled: bool = True # /metrics endpoint features_version_enabled: bool = True # /version endpoint features_docs_enabled: bool = True # /docs endpoint features_redoc_enabled: bool = True # /redoc endpoint features_connection_tester_enabled: bool = True # Connection testing in UI (future/not implemented) # Helper property to get enabled features as a list @property def enabled_features(self) -> List[str]: """Get list of enabled MCP features.""" features = [] if self.features_tools_enabled: features.append("tools") if self.features_resources_enabled: features.append("resources") if self.features_prompts_enabled: features.append("prompts") if self.features_servers_enabled: features.append("servers") if self.features_gateways_enabled: features.append("gateways") if self.features_roots_enabled: features.append("roots") if self.features_tags_enabled: features.append("tags") return features @property def enabled_system_features(self) -> List[str]: """Get list of enabled system features.""" features = [] if self.features_reverse_proxy_enabled: features.append("reverse_proxy") if self.features_rest_api_tools_enabled: features.append("rest_api_tools") if self.features_metrics_enabled: features.append("metrics") if self.features_version_enabled: features.append("version") if self.features_docs_enabled: features.append("docs") if self.features_redoc_enabled: features.append("redoc") if self.features_connection_tester_enabled: features.append("connection_tester") return features # Helper to check if a feature is enabled def is_feature_enabled(self, feature: str) -> bool: """Check if a specific feature is enabled.""" return feature in self.enabled_features or feature in self.enabled_system_features

# In mcpgateway/main.py # Always create the base app app = FastAPI( title=settings.app_name, version=__version__, docs_url="/docs" if settings.features_docs_enabled else None, redoc_url="/redoc" if settings.features_redoc_enabled else None, openapi_url="/openapi.json" if (settings.features_docs_enabled or settings.features_redoc_enabled) else None, ) # Include routers based on feature flags app.include_router(protocol_router) # Always include protocol # Version endpoint - conditional if settings.features_version_enabled: app.include_router(version_router) else: logger.info("Version feature disabled - not mounting version routes") # Conditionally include feature routers if settings.features_tools_enabled: app.include_router(tool_router) else: logger.info("Tools feature disabled - not mounting tool routes") if settings.features_resources_enabled: app.include_router(resource_router) else: logger.info("Resources feature disabled - not mounting resource routes") if settings.features_prompts_enabled: app.include_router(prompt_router) else: logger.info("Prompts feature disabled - not mounting prompt routes") if settings.features_servers_enabled: app.include_router(server_router) else: logger.info("Servers feature disabled - not mounting server routes") if settings.features_gateways_enabled: app.include_router(gateway_router) else: logger.info("Gateways feature disabled - not mounting gateway routes") if settings.features_roots_enabled: app.include_router(root_router) else: logger.info("Roots feature disabled - not mounting root routes") # Tags endpoint - conditional if settings.features_tags_enabled: app.include_router(tag_router) else: logger.info("Tags feature disabled - not mounting tag routes") # Always include utility router app.include_router(utility_router) # Metrics endpoint - conditional if settings.features_metrics_enabled: app.include_router(metrics_router) else: logger.info("Metrics feature disabled - not mounting metrics routes") # Reverse proxy router - conditional (handles existing conditional import) if settings.features_reverse_proxy_enabled: try: from mcpgateway.routers.reverse_proxy import router as reverse_proxy_router app.include_router(reverse_proxy_router) logger.info("Reverse proxy router included") except ImportError: logger.warning("Reverse proxy router not available - feature disabled") else: logger.info("Reverse proxy feature disabled - not mounting reverse proxy routes") # Admin UI - if enabled if settings.mcpgateway_ui_enabled: app.include_router(admin_router)

# In mcpgateway/version.py from mcpgateway.config import settings @router.get("/version", summary="Diagnostics (auth required)") async def version_endpoint( request: Request, fmt: Optional[str] = None, partial: Optional[bool] = False, _user=Depends(require_auth), ) -> Response: """Update existing version endpoint to include feature information.""" # ... existing Redis health check and payload building logic ... # Extend the existing payload with feature information payload = _build_payload(redis_version, redis_ok) # Add feature information to existing payload payload.update({ "features_enabled": settings.enabled_features, "system_features_enabled": settings.enabled_system_features, "features": { # MCP Features "tools": settings.features_tools_enabled, "resources": settings.features_resources_enabled, "prompts": settings.features_prompts_enabled, "servers": settings.features_servers_enabled, "gateways": settings.features_gateways_enabled, "roots": settings.features_roots_enabled, "tags": settings.features_tags_enabled, # System Features "reverse_proxy": settings.features_reverse_proxy_enabled, "rest_api_tools": settings.features_rest_api_tools_enabled, "metrics": settings.features_metrics_enabled, "version": settings.features_version_enabled, "docs": settings.features_docs_enabled, "redoc": settings.features_redoc_enabled, "connection_tester": settings.features_connection_tester_enabled, } }) # Return response using existing format logic if partial: templates = Jinja2Templates(directory=str(settings.templates_dir)) return templates.TemplateResponse(request, "version_info_partial.html", {"request": request, "payload": payload}) wants_html = fmt == "html" or "text/html" in request.headers.get("accept", "") if wants_html: return HTMLResponse(_render_html(payload)) return JSONResponse(payload)

# In mcpgateway/cache/session_registry.py async def handle_initialize_logic(self, body: Dict[str, Any]) -> InitializeResult: """Handle initialize request, only advertising enabled capabilities.""" # ... existing validation logic ... capabilities = {} if settings.features_tools_enabled: capabilities["tools"] = {"listChanged": True} if settings.features_resources_enabled: capabilities["resources"] = {"subscribe": True, "listChanged": True} if settings.features_prompts_enabled: capabilities["prompts"] = {"listChanged": True} if settings.features_roots_enabled: capabilities["roots"] = {"listChanged": True} # Always include logging capability capabilities["logging"] = {} return InitializeResult( protocolVersion=settings.protocol_version, capabilities=ServerCapabilities(**capabilities), serverInfo=Implementation( name=settings.app_name, version=__version__, features_enabled=settings.enabled_features, system_features_enabled=settings.enabled_system_features, ), instructions=("MCP Gateway providing federated tools, resources and prompts. Use /admin interface for configuration."), )

# Future implementation or in bulk import logic async def discover_rest_api_tools(): """Discover and convert REST APIs to MCP tools.""" if not settings.features_rest_api_tools_enabled: logger.info("REST API tools feature disabled - skipping REST API discovery") return [] # ... future REST API discovery logic ...

# In mcpgateway/admin.py - pass settings to template context @admin_router.get("/") async def admin_dashboard(request: Request, user: str = Depends(require_auth)): """Admin dashboard.""" return templates.TemplateResponse( "admin.html", {"request": request, "config": settings} # Add settings to context )

# Future implementation in mcpgateway/admin.py when connection tester is built # @admin_router.get("/test-connection") # Future endpoint # async def test_connection_page(request: Request): # """Connection test page (future implementation).""" # if not settings.features_connection_tester_enabled: # raise HTTPException(status_code=404, detail="Connection tester is disabled") #  # # Future: return test connection UI template