add required parameters

Author: alexcheng1982

README.md

@@ -0,0 +1,2 @@
+# OpenAPI MCP Server
+

build.gradle.kts

@@ -28,6 +28,7 @@ dependencies {
     implementation("ch.qos.logback:logback-classic:${logbackVersion}")
     implementation("io.ktor:ktor-client-content-negotiation:${ktorVersion}")
     implementation("io.ktor:ktor-serialization-kotlinx-json:${ktorVersion}")
+    implementation("io.ktor:ktor-client-logging:${ktorVersion}")
     implementation("info.picocli:picocli:${picocliVersion}")
     implementation("io.swagger.parser.v3:swagger-parser:${swaggerParserVersion}")
     testImplementation(kotlin("test"))

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

@@ -3,6 +3,7 @@ package com.javaaidev.mcp.openapi
 import io.ktor.client.*
 import io.ktor.client.plugins.*
 import io.ktor.client.plugins.contentnegotiation.*
+import io.ktor.client.plugins.logging.*
 import io.ktor.client.request.*
 import io.ktor.client.statement.*
 import io.ktor.http.*
@@ -32,6 +33,11 @@ object McpToolHelper {
                 prettyPrint = true
             })
         }
+        install(Logging) {
+            logger = Logger.DEFAULT
+            level = LogLevel.INFO
+            sanitizeHeader { header -> header == HttpHeaders.Authorization }
+        }
     }
 
     fun toTools(openAPI: OpenAPI): List<McpTool> {
@@ -58,7 +64,7 @@ object McpToolHelper {
     ): McpTool {
         val name = operation.operationId ?: "${httpMethod}_$path"
         val description = operation.description ?: (operation.summary ?: "")
-        val parameters = operationParameters(operation, components)
+        val (parameters, requiredParams) = operationParameters(operation, components)
         val requestBody = operationRequestBody(operation, components)
         val responseBody = operationResponseBody(operation, components)
         val toolAnnotations = if (httpMethod == "GET")
@@ -76,15 +82,18 @@ object McpToolHelper {
                             "parameters" to JsonObject(
                                 mapOf(
                                     "type" to JsonPrimitive("object"),
-                                    "properties" to parameters
+                                    "properties" to parameters,
+                                    "required" to JsonArray((requiredParams ?: listOf()).map {
+                                        JsonPrimitive(it)
+                                    })
                                 )
                             ),
                             "requestBody" to requestBody,
                         )
                     )
                 )
             } else if (parameters?.isNotEmpty() == true) {
-                Tool.Input(parameters, parameters.keys.toList())
+                Tool.Input(parameters, requiredParams)
             } else if (requestBody?.isNotEmpty() == true) {
                 Tool.Input(
                     requestBody["properties"] as? JsonObject ?: JsonObject(mapOf()),
@@ -127,14 +136,16 @@ object McpToolHelper {
     private fun operationParameters(
         operation: Operation,
         components: Map<String, Schema<*>>?
-    ): JsonObject? {
-        return operation.parameters?.filter { parameter ->
+    ): Pair<JsonObject?, List<String>?> {
+        val parameters = operation.parameters?.filter { parameter ->
             setOf("query", "path").contains(parameter.`in`)
-        }?.associate { parameter ->
+        }
+        val required = parameters?.filter { it.required }?.map { it.name }
+        return (parameters?.associate { parameter ->
             parameter.name to schemaToJsonObject(parameter.schema, components, parameter)
         }?.let {
             JsonObject(it)
-        }
+        } to required)
     }
 
     private fun operationRequestBody(operation: Operation, components: Map<String, Schema<*>>?) =
@@ -232,7 +243,9 @@ object McpToolHelper {
     private fun expandUriTemplate(template: String, values: JsonObject): String {
         var result = template
         values.forEach { (key, value) ->
-            result = result.replace("{$key}", value.toString())
+            if (value is JsonPrimitive) {
+                result = result.replace("{$key}", value.contentOrNull ?: "")
+            }
         }
         return result
     }

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

@@ -7,12 +7,12 @@ import io.swagger.v3.parser.core.models.ParseOptions
 object OpenAPIParser {
     fun parse(spec: String): OpenAPI {
         val parseOption = ParseOptions()
-//        parseOption.isFlatten = true
+        parseOption.isFlatten = false
         parseOption.isResolveFully = true
         parseOption.isResolveRequestBody = true
         parseOption.isResolveResponses = true
         parseOption.isResolve = true
-//        parseOption.isFlattenComposedSchemas = true
+        parseOption.isFlattenComposedSchemas = false
         val result = OpenAPIParser().readLocation(spec, null, parseOption)
         return result?.openAPI
             ?: throw RuntimeException("OpenAPI spec parse error: ${result.messages}")

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

@@ -13,10 +13,12 @@ import kotlinx.io.buffered
 
 object McpServer {
     fun start(openapiSpec: String) {
+        val openAPI = OpenAPIParser.parse(openapiSpec)
+
         val server = Server(
             Implementation(
-                name = "openapi",
-                version = "1.0.0"
+                name = openAPI.info?.title ?: "openapi-mcp-server",
+                version = openAPI.info?.version ?: "1.0.0"
             ),
             ServerOptions(
                 capabilities = ServerCapabilities(
@@ -26,13 +28,12 @@ object McpServer {
             )
         )
 
-        val openAPI = OpenAPIParser.parse(openapiSpec)
         McpToolHelper.toTools(openAPI).forEach { tool ->
             server.addTool(tool.tool, tool.handler)
         }
 
         val transport = StdioServerTransport(
-            System.`in`.asInput(),
+            System.`in`.asInput().buffered(),
             System.out.asSink().buffered()
         )