Added mcp Ktor server route alongside Application extension

Author: Mr3zee

README.md

@@ -114,12 +114,13 @@ server.connect(transport)
 
 ### Using SSE Transport
 
+Directly in Ktor's `Application`:
 ```kotlin
 import io.ktor.server.application.*
-import io.modelcontextprotocol.kotlin.sdk.server.MCP
+import io.modelcontextprotocol.kotlin.sdk.server.mcp
 
 fun Application.module() {
-    MCP {
+    mcp {
         Server(
             serverInfo = Implementation(
                 name = "example-sse-server",
@@ -136,6 +137,35 @@ fun Application.module() {
 }
 ```
 
+Inside a custom Ktor's `Route`:
+```kotlin
+import io.ktor.server.application.*
+import io.ktor.server.sse.SSE
+import io.modelcontextprotocol.kotlin.sdk.server.mcp
+
+fun Application.module() {
+    install(SSE)
+
+    routing {
+        route("myRoute") {
+            mcp {
+                Server(
+                    serverInfo = Implementation(
+                        name = "example-sse-server",
+                        version = "1.0.0"
+                    ),
+                    options = ServerOptions(
+                        capabilities = ServerCapabilities(
+                            prompts = ServerCapabilities.Prompts(listChanged = null),
+                            resources = ServerCapabilities.Resources(subscribe = null, listChanged = null)
+                        )
+                    )
+                )
+            }
+        }
+    }
+}
+```
 ## Contributing
 
 Please see the [contribution guide](CONTRIBUTING.md) and the [Code of conduct](CODE_OF_CONDUCT.md) before contributing.

build.gradle.kts

@@ -225,6 +225,7 @@ kotlin {
         jvmTest {
             dependencies {
                 implementation(libs.mockk)
+                implementation(libs.slf4j.simple)
             }
         }
     }

gradle/libs.versions.toml

@@ -12,6 +12,7 @@ mockk = "1.13.13"
 logging = "7.0.0"
 jreleaser = "1.15.0"
 binaryCompatibilityValidatorPlugin = "0.17.0"
+slf4j = "2.0.16"
 
 [libraries]
 # Kotlinx libraries
@@ -30,6 +31,7 @@ kotlinx-coroutines-test = { group = "org.jetbrains.kotlinx", name = "kotlinx-cor
 kotlinx-coroutines-debug = { group = "org.jetbrains.kotlinx", name = "kotlinx-coroutines-debug", version.ref = "coroutines" }
 ktor-server-test-host = { group = "io.ktor", name = "ktor-server-test-host", version.ref = "ktor" }
 mockk = { group = "io.mockk", name = "mockk", version.ref = "mockk" }
+slf4j-simple = { group = "org.slf4j", name = "slf4j-simple", version.ref = "slf4j" }
 
 
 

src/commonMain/kotlin/io/modelcontextprotocol/kotlin/sdk/server/KtorServer.kt

@@ -0,0 +1,110 @@
+package io.modelcontextprotocol.kotlin.sdk.server
+
+import io.github.oshai.kotlinlogging.KotlinLogging
+import io.ktor.http.*
+import io.ktor.server.application.*
+import io.ktor.server.response.*
+import io.ktor.server.routing.*
+import io.ktor.server.sse.*
+import io.ktor.util.collections.*
+import io.ktor.utils.io.KtorDsl
+
+private val logger = KotlinLogging.logger {}
+
+@KtorDsl
+public fun Routing.mcp(path: String, block: () -> Server) {
+    route(path) {
+        mcp(block)
+    }
+}
+
+/**
+ * Configures the Ktor Application to handle Model Context Protocol (MCP) over Server-Sent Events (SSE).
+ */
+@KtorDsl
+public fun Routing.mcp(block: () -> Server) {
+    val transports = ConcurrentMap<String, SseServerTransport>()
+
+    sse {
+        mcpSseEndpoint("", transports, block)
+    }
+
+    post {
+        mcpPostEndpoint(transports)
+    }
+}
+
+@Suppress("FunctionName")
+@Deprecated("Use mcp() instead", ReplaceWith("mcp(block)"), DeprecationLevel.WARNING)
+public fun Application.MCP(block: () -> Server) {
+    mcp(block)
+}
+
+@KtorDsl
+public fun Application.mcp(block: () -> Server) {
+    val transports = ConcurrentMap<String, SseServerTransport>()
+
+    install(SSE)
+
+    routing {
+        sse("/sse") {
+            mcpSseEndpoint("/message", transports, block)
+        }
+
+        post("/message") {
+            mcpPostEndpoint(transports)
+        }
+    }
+}
+
+private suspend fun ServerSSESession.mcpSseEndpoint(
+    postEndpoint: String,
+    transports: ConcurrentMap<String, SseServerTransport>,
+    block: () -> Server,
+) {
+    val transport =  mcpSseTransport(postEndpoint, transports)
+
+    val server = block()
+
+    server.onClose {
+        logger.info { "Server connection closed for sessionId: ${transport.sessionId}" }
+        transports.remove(transport.sessionId)
+    }
+
+    server.connect(transport)
+    logger.debug { "Server connected to transport for sessionId: ${transport.sessionId}" }
+}
+
+internal fun ServerSSESession.mcpSseTransport(
+    postEndpoint: String,
+    transports: ConcurrentMap<String, SseServerTransport>,
+): SseServerTransport {
+    val transport = SseServerTransport(postEndpoint, this)
+    transports[transport.sessionId] = transport
+
+    logger.info { "New SSE connection established and stored with sessionId: ${transport.sessionId}" }
+
+    return transport
+}
+
+internal suspend fun RoutingContext.mcpPostEndpoint(
+    transports: ConcurrentMap<String, SseServerTransport>,
+) {
+    val sessionId: String = call.request.queryParameters["sessionId"]
+        ?: run {
+            call.respond(HttpStatusCode.BadRequest, "sessionId query parameter is not provided")
+            return
+        }
+
+    logger.debug { "Received message for sessionId: $sessionId" }
+
+    val transport = transports[sessionId]
+    if (transport == null) {
+        logger.warn { "Session not found for sessionId: $sessionId" }
+        call.respond(HttpStatusCode.NotFound, "Session not found")
+        return
+    }
+
+    transport.handlePostMessage(call)
+    logger.trace { "Message handled for sessionId: $sessionId" }
+}