add operation filters

Author: alexcheng1982

src/main/kotlin/com/javaaidev/mcp/openapi/Cli.kt

@@ -4,10 +4,6 @@ import picocli.CommandLine
 import java.util.concurrent.Callable
 import kotlin.system.exitProcess
 
-enum class TransportType {
-    stdio, httpSse, streamableHttp
-}
-
 @CommandLine.Command(
     name = "openapi-mcp",
     mixinStandardHelpOptions = true,
@@ -19,14 +15,31 @@ class Cli : Callable<Int> {
     lateinit var openapiSpec: String
 
     @CommandLine.Option(
-        names = ["--transport"],
-        defaultValue = "stdio",
-        description = [$$"MCP transport type. Valid values: ${COMPLETION-CANDIDATES}"],
+        names = ["--include-operation-id"],
+        split = ",",
+        description = ["Include operations with id (comma separated)"]
+    )
+    private val includeOperationIds: List<String>? = null
+
+    @CommandLine.Option(
+        names = ["--include-http-method"],
+        split = ",",
+        description = ["Include operations with HTTP methods (comma separated)"]
+    )
+    private val includeHttpMethods: List<String>? = null
+
+    @CommandLine.Option(
+        names = ["--include-path"],
+        split = ",",
+        description = ["Include operations with paths (comma separated)"]
     )
-    var transportType: TransportType = TransportType.stdio
+    private val includePaths: List<String>? = null
 
     override fun call(): Int {
-        McpServer.start(openapiSpec)
+        McpServer.start(
+            openapiSpec,
+            OpenAPIOperationFilter(includeOperationIds, includeHttpMethods, includePaths)
+        )
         return 0
     }
 }

src/main/kotlin/com/javaaidev/mcp/openapi/McpTool.kt

@@ -16,6 +16,45 @@ import io.swagger.v3.oas.models.media.Schema
 import io.swagger.v3.oas.models.media.StringSchema
 import io.swagger.v3.oas.models.parameters.Parameter
 import kotlinx.serialization.json.*
+import org.apache.commons.lang3.StringUtils
+import java.util.function.Supplier
+
+data class OpenAPIOperation(
+    val operation: Operation,
+    val httpMethod: String,
+    val path: String,
+)
+
+data class OpenAPIOperationFilter(
+    val operationIds: List<String>? = null,
+    val httpMethods: List<String>? = null,
+    val paths: List<String>? = null,
+) {
+    fun match(operation: OpenAPIOperation): Boolean {
+        val checkers = mutableListOf<Supplier<Boolean>>()
+        operationIds?.let {
+            checkers.add {
+                StringUtils.isNotBlank(operation.operation.operationId)
+                        && it.contains(operation.operation.operationId)
+            }
+        }
+        httpMethods?.let {
+            checkers.add {
+                it.any { method ->
+                    method.equals(operation.httpMethod, true)
+                }
+            }
+        }
+        paths?.let {
+            checkers.add {
+                it.any { path ->
+                    path.equals(operation.path, true)
+                }
+            }
+        }
+        return checkers.all { it.get() }
+    }
+}
 
 data class McpTool(
     val tool: Tool,
@@ -46,18 +85,29 @@ object McpToolHelper {
         }
     }
 
-    fun toTools(openAPI: OpenAPI): List<McpTool> {
+    fun toTools(
+        openAPI: OpenAPI,
+        openAPIOperationFilter: OpenAPIOperationFilter? = null
+    ): List<McpTool> {
+        logger.info("Create tools with filter {}", openAPIOperationFilter)
         val serverUrl = openAPI.servers.first().url
         val components = openAPI.components?.schemas
-        return openAPI.paths?.entries?.flatMap { entry ->
+        val operations = openAPI.paths?.entries?.flatMap { entry ->
             val path = entry.key
             listOfNotNull(
-                entry.value.get?.let { toTool(serverUrl, it, "GET", path, components) },
-                entry.value.post?.let { toTool(serverUrl, it, "POST", path, components) },
-                entry.value.put?.let { toTool(serverUrl, it, "PUT", path, components) },
-                entry.value.delete?.let { toTool(serverUrl, it, "DELETE", path, components) },
-                entry.value.patch?.let { toTool(serverUrl, it, "PATCH", path, components) },
+                entry.value.get?.let { OpenAPIOperation(it, "GET", path) },
+                entry.value.post?.let { OpenAPIOperation(it, "POST", path) },
+                entry.value.put?.let { OpenAPIOperation(it, "PUT", path) },
+                entry.value.delete?.let { OpenAPIOperation(it, "DELETE", path) },
+                entry.value.patch?.let { OpenAPIOperation(it, "PATCH", path) },
             )
+        }?.also {
+            logger.info("Found {} operations", it.size)
+        }?.filter { operation -> openAPIOperationFilter?.match(operation) ?: true }?.also {
+            logger.info("Use {} operations after filtering", it.size)
+        }
+        return operations?.map {
+            toTool(serverUrl, it.operation, it.httpMethod, it.path, components)
         } ?: listOf()
     }
 

src/main/kotlin/com/javaaidev/mcp/openapi/Server.kt

@@ -10,9 +10,15 @@ import kotlinx.coroutines.Job
 import kotlinx.coroutines.runBlocking
 import kotlinx.io.asSink
 import kotlinx.io.buffered
+import org.slf4j.Logger
+import org.slf4j.LoggerFactory
+
+val logger: Logger = LoggerFactory.getLogger("McpServer")
 
 object McpServer {
-    fun start(openapiSpec: String) {
+
+    fun start(openapiSpec: String, openAPIOperationFilter: OpenAPIOperationFilter? = null) {
+        logger.info("Parse OpenAPI spec {} ", openapiSpec)
         val openAPI = OpenAPIParser.parse(openapiSpec)
 
         val server = Server(
@@ -28,7 +34,7 @@ object McpServer {
             )
         )
 
-        McpToolHelper.toTools(openAPI).forEach { tool ->
+        McpToolHelper.toTools(openAPI, openAPIOperationFilter).forEach { tool ->
             server.addTool(tool.tool, tool.handler)
         }
 

src/test/kotlin/com/javaaidev/mcp/openapi/McpToolHelperTest.kt

@@ -1,21 +1,53 @@
 package com.javaaidev.mcp.openapi
 
 import kotlin.test.Test
+import kotlin.test.assertEquals
 import kotlin.test.assertTrue
 
 class McpToolHelperTest {
     @Test
     fun testParsePetStoreAPI() {
         val openAPI = OpenAPIParser.parse("https://petstore.swagger.io/v2/swagger.json")
-        val tools = McpToolHelper.toTools(openAPI)
+        val tools = McpToolHelper.toTools(openAPI, null)
         assertTrue(tools.isNotEmpty())
     }
 
     @Test
     fun testParseCanadaHolidaysAPI() {
         val openAPI =
             OpenAPIParser.parse("https://api.apis.guru/v2/specs/canada-holidays.ca/1.8.0/openapi.json")
-        val tools = McpToolHelper.toTools(openAPI)
+        val tools = McpToolHelper.toTools(openAPI, null)
         assertTrue(tools.isNotEmpty())
     }
+
+    @Test
+    fun testOperationFilter() {
+        val openAPI =
+            OpenAPIParser.parse("https://api.apis.guru/v2/specs/canada-holidays.ca/1.8.0/openapi.json")
+        var tools = McpToolHelper.toTools(
+            openAPI, OpenAPIOperationFilter(
+                listOf("Root")
+            )
+        )
+        assertEquals(1, tools.size)
+        tools = McpToolHelper.toTools(
+            openAPI, OpenAPIOperationFilter(
+                httpMethods = listOf("POST")
+            )
+        )
+        assertEquals(0, tools.size)
+        tools = McpToolHelper.toTools(
+            openAPI, OpenAPIOperationFilter(
+                paths = listOf("/api/v1/holidays")
+            )
+        )
+        assertEquals(1, tools.size)
+        tools = McpToolHelper.toTools(
+            openAPI, OpenAPIOperationFilter(
+                listOf("Root"),
+                httpMethods = listOf("GET")
+            )
+        )
+        assertEquals(1, tools.size)
+    }
 }