Kotlin MCP サーバープロジェクトジェネレータ

Kotlin で完全でプロダクションレディな Model Context Protocol (MCP) サーバープロジェクトを生成します。

プロジェクト要件

以下の内容を含む Kotlin MCP サーバーを作成します：

1. プロジェクト構造: Gradle ベースの Kotlin プロジェクトレイアウト
2. 依存関係: 公式 MCP SDK、Ktor、kotlinx ライブラリ
3. サーバーセットアップ: トランスポート設定済みの MCP サーバー
4. ツール: 型付き入出力を備えた 2～3 個の有用なツール
5. エラーハンドリング: 適切な例外処理と検証
6. ドキュメント: セットアップと使用方法の README
7. テスト: コルーチンを使用した基本的なテスト構造

テンプレート構造

myserver/
├── build.gradle.kts
├── settings.gradle.kts
├── gradle.properties
├── src/
│   ├── main/
│   │   └── kotlin/
│   │       └── com/example/myserver/
│   │           ├── Main.kt
│   │           ├── Server.kt
│   │           ├── config/
│   │           │   └── Config.kt
│   │           └── tools/
│   │               ├── Tool1.kt
│   │               └── Tool2.kt
│   └── test/
│       └── kotlin/
│           └── com/example/myserver/
│               └── ServerTest.kt
└── README.md

build.gradle.kts テンプレート

plugins {
    kotlin("jvm") version "2.1.0"
    kotlin("plugin.serialization") version "2.1.0"
    application
}

group = "com.example"
version = "1.0.0"

repositories {
    mavenCentral()
}

dependencies {
    implementation("io.modelcontextprotocol:kotlin-sdk:0.7.2")
    
    // Ktor for transports
    implementation("io.ktor:ktor-server-netty:3.0.0")
    implementation("io.ktor:ktor-client-cio:3.0.0")
    
    // Serialization
    implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.7.3")
    
    // Coroutines
    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.9.0")
    
    // Logging
    implementation("io.github.oshai:kotlin-logging-jvm:7.0.0")
    implementation("ch.qos.logback:logback-classic:1.5.12")
    
    // Testing
    testImplementation(kotlin("test"))
    testImplementation("org.jetbrains.kotlinx:kotlinx-coroutines-test:1.9.0")
}

application {
    mainClass.set("com.example.myserver.MainKt")
}

tasks.test {
    useJUnitPlatform()
}

kotlin {
    jvmToolchain(17)
}

settings.gradle.kts テンプレート

rootProject.name = "{{PROJECT_NAME}}"

Main.kt テンプレート

package com.example.myserver

import io.modelcontextprotocol.kotlin.sdk.server.StdioServerTransport
import kotlinx.coroutines.runBlocking
import io.github.oshai.kotlinlogging.KotlinLogging

private val logger = KotlinLogging.logger {}

fun main() = runBlocking {
    logger.info { "Starting MCP server..." }
    
    val config = loadConfig()
    val server = createServer(config)
    
    // Use stdio transport
    val transport = StdioServerTransport()
    
    logger.info { "Server '${config.name}' v${config.version} ready" }
    server.connect(transport)
}

Server.kt テンプレート

package com.example.myserver

import io.modelcontextprotocol.kotlin.sdk.server.Server
import io.modelcontextprotocol.kotlin.sdk.server.ServerOptions
import io.modelcontextprotocol.kotlin.sdk.Implementation
import io.modelcontextprotocol.kotlin.sdk.ServerCapabilities
import com.example.myserver.tools.registerTools

fun createServer(config: Config): Server {
    val server = Server(
        serverInfo = Implementation(
            name = config.name,
            version = config.version
        ),
        options = ServerOptions(
            capabilities = ServerCapabilities(
                tools = ServerCapabilities.Tools(),
                resources = ServerCapabilities.Resources(
                    subscribe = true,
                    listChanged = true
                ),
                prompts = ServerCapabilities.Prompts(listChanged = true)
            )
        )
    ) {
        config.description
    }
    
    // Register all tools
    server.registerTools()
    
    return server
}

Config.kt テンプレート

package com.example.myserver.config

import kotlinx.serialization.Serializable

@Serializable
data class Config(
    val name: String = "{{PROJECT_NAME}}",
    val version: String = "1.0.0",
    val description: String = "{{PROJECT_DESCRIPTION}}"
)

fun loadConfig(): Config {
    return Config(
        name = System.getenv("SERVER_NAME") ?: "{{PROJECT_NAME}}",
        version = System.getenv("VERSION") ?: "1.0.0",
        description = System.getenv("DESCRIPTION") ?: "{{PROJECT_DESCRIPTION}}"
    )
}

Tool1.kt テンプレート

package com.example.myserver.tools

import io.modelcontextprotocol.kotlin.sdk.server.Server
import io.modelcontextprotocol.kotlin.sdk.CallToolRequest
import io.modelcontextprotocol.kotlin.sdk.CallToolResult
import io.modelcontextprotocol.kotlin.sdk.TextContent
import kotlinx.serialization.json.buildJsonObject
import kotlinx.serialization.json.put
import kotlinx.serialization.json.putJsonObject
import kotlinx.serialization.json.putJsonArray

fun Server.registerTool1() {
    addTool(
        name = "tool1",
        description = "Description of what tool1 does",
        inputSchema = buildJsonObject {
            put("type", "object")
            putJsonObject("properties") {
                putJsonObject("param1") {
                    put("type", "string")
                    put("description", "First parameter")
                }
                putJsonObject("param2") {
                    put("type", "integer")
                    put("description", "Optional second parameter")
                }
            }
            putJsonArray("required") {
                add("param1")
            }
        }
    ) { request: CallToolRequest ->
        // Extract and validate parameters
        val param1 = request.params.arguments["param1"] as? String
            ?: throw IllegalArgumentException("param1 is required")
        val param2 = (request.params.arguments["param2"] as? Number)?.toInt() ?: 0
        
        // Perform tool logic
        val result = performTool1Logic(param1, param2)
        
        CallToolResult(
            content = listOf(
                TextContent(text = result)
            )
        )
    }
}

private fun performTool1Logic(param1: String, param2: Int): String {
    // Implement tool logic here
    return "Processed: $param1 with value $param2"
}

tools/ToolRegistry.kt テンプレート

package com.example.myserver.tools

import io.modelcontextprotocol.kotlin.sdk.server.Server

fun Server.registerTools() {
    registerTool1()
    registerTool2()
    // Register additional tools here
}

ServerTest.kt テンプレート

package com.example.myserver

import kotlinx.coroutines.test.runTest
import kotlin.test.Test
import kotlin.test.assertEquals
import kotlin.test.assertFalse

class ServerTest {
    
    @Test
    fun `test server creation`() = runTest {
        val config = Config(
            name = "test-server",
            version = "1.0.0",
            description = "Test server"
        )
        
        val server = createServer(config)
        
        assertEquals("test-server", server.serverInfo.name)
        assertEquals("1.0.0", server.serverInfo.version)
    }
    
    @Test
    fun `test tool1 execution`() = runTest {
        val config = Config()
        val server = createServer(config)
        
        // Test tool execution
        // Note: You'll need to implement proper testing utilities
        // for calling tools in the server
    }
}

README.md テンプレート

# {{PROJECT_NAME}}

Kotlin で構築された Model Context Protocol (MCP) サーバー

## 説明

{{PROJECT_DESCRIPTION}}

## 必要な環境

- Java 17 以上
- Kotlin 2.1.0

## インストール

プロジェクトをビルドします：

\`\`\`bash
./gradlew build
\`\`\`

## 使用方法

stdio トランスポートでサーバーを実行します：

\`\`\`bash
./gradlew run
\`\`\`

または jar をビルドして実行します：

\`\`\`bash
./gradlew installDist
./build/install/{{PROJECT_NAME}}/bin/{{PROJECT_NAME}}
\`\`\`

## 設定

環境変数で設定します：

- `SERVER_NAME`: サーバー名 (デフォルト: "{{PROJECT_NAME}}")
- `VERSION`: サーバーバージョン (デフォルト: "1.0.0")
- `DESCRIPTION`: サーバーの説明

## 利用可能なツール

### tool1
{{TOOL1_DESCRIPTION}}

**入力:**
- `param1` (文字列、必須): 最初のパラメータ
- `param2` (整数、オプション): 2 番目のパラメータ

**出力:**
- 操作の結果のテキスト

## 開発

テストを実行します：

\`\`\`bash
./gradlew test
\`\`\`

ビルド：

\`\`\`bash
./gradlew build
\`\`\`

自動リロード付きで実行（開発時）：

\`\`\`bash
./gradlew run --continuous
\`\`\`

## マルチプラットフォーム

このプロジェクトは Kotlin Multiplatform を使用し、JVM、Wasm、iOS をターゲットにできます。
プラットフォーム設定については `build.gradle.kts` を参照してください。

## ライセンス

MIT

生成手順

Kotlin MCP サーバーを生成するとき：

1. Gradle セットアップ: すべての依存関係を含む適切な build.gradle.kts を作成
2. パッケージ構造: Kotlin パッケージ規約に従う
3. 型安全性: データクラスと kotlinx.serialization を使用
4. コルーチン: すべての操作はサスペンド関数であるべき
5. エラーハンドリング: Kotlin 例外と検証を使用
6. JSON スキーマ: ツールスキーマには buildJsonObject を使用
7. テスト: コルーチンテストユーティリティを含める
8. ロギング: 構造化ロギングに kotlin-logging を使用
9. 設定: データクラスと環境変数を使用
10. ドキュメント: 公開 API に KDoc コメントを付ける

ベストプラクティス

• すべての非同期操作にはサスペンド関数を使用
• Kotlin の null 安全性と型システムを活用
• 構造化データにはデータクラスを使用
• JSON 処理には kotlinx.serialization を適用
• 結果型には sealed クラスを使用
• Result/Either パターンで適切なエラーハンドリングを実装
• kotlinx-coroutines-test を使用してテストを記述
• テスト可能性のために依存性注入を使用
• Kotlin コーディング規約に従う
• 意味のある名前と KDoc コメントを使用

トランスポートオプション

Stdio トランスポート

val transport = StdioServerTransport()
server.connect(transport)

SSE トランスポート (Ktor)

embeddedServer(Netty, port = 8080) {
    mcp {
        Server(/*...*/) { "Description" }
    }
}.start(wait = true)

マルチプラットフォーム設定

マルチプラットフォームプロジェクトの場合、build.gradle.kts に以下を追加します：

kotlin {
    jvm()
    js(IR) { nodejs() }
    wasmJs()
    
    sourceSets {
        commonMain.dependencies {
            implementation("io.modelcontextprotocol:kotlin-sdk:0.7.2")
        }
    }
}