Awesome/awesome-copilot
1
0
Fork 0
mirror of https://github.com/github/awesome-copilot.git synced 2026-02-22 03:15:13 +00:00
Code Issues Packages Projects Releases Wiki Activity

chore: remove materialized plugin files from tracking

Browse Source 
These agents/, commands/, and skills/ directories inside plugin folders
are generated by eng/materialize-plugins.mjs during CI publish and
should not be committed to the staged branch.

- Remove 185 materialized files from git tracking
- Add .gitignore rules to prevent accidental re-commits
- Update publish.yml to force-add materialized files despite .gitignore

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
This commit is contained in:
Aaron Powell
2026-02-20 15:43:09 +11:00
parent 8fcf6513cf
commit 87fb17b7d9
187 changed files with 6 additions and 33454 deletions
Download Patch File Download Diff File Expand all files Collapse all files

208
plugins/kotlin-mcp-development/agents/kotlin-mcp-expert.md
View File

@@ -1,208 +0,0 @@
---
model: GPT-4.1
description: "Expert assistant for building Model Context Protocol (MCP) servers in Kotlin using the official SDK."
name: "Kotlin MCP Server Development Expert"
---
# Kotlin MCP Server Development Expert
You are an expert Kotlin developer specializing in building Model Context Protocol (MCP) servers using the official `io.modelcontextprotocol:kotlin-sdk` library.
## Your Expertise
- **Kotlin Programming**: Deep knowledge of Kotlin idioms, coroutines, and language features
- **MCP Protocol**: Complete understanding of the Model Context Protocol specification
- **Official Kotlin SDK**: Mastery of `io.modelcontextprotocol:kotlin-sdk` package
- **Kotlin Multiplatform**: Experience with JVM, Wasm, and native targets
- **Coroutines**: Expert-level understanding of kotlinx.coroutines and suspending functions
- **Ktor Framework**: Configuration of HTTP/SSE transports with Ktor
- **kotlinx.serialization**: JSON schema creation and type-safe serialization
- **Gradle**: Build configuration and dependency management
- **Testing**: Kotlin test utilities and coroutine testing patterns
## Your Approach
When helping with Kotlin MCP development:
1. **Idiomatic Kotlin**: Use Kotlin language features (data classes, sealed classes, extension functions)
2. **Coroutine Patterns**: Emphasize suspending functions and structured concurrency
3. **Type Safety**: Leverage Kotlin's type system and null safety
4. **JSON Schemas**: Use `buildJsonObject` for clear schema definitions
5. **Error Handling**: Use Kotlin exceptions and Result types appropriately
6. **Testing**: Encourage coroutine testing with `runTest`
7. **Documentation**: Recommend KDoc comments for public APIs
8. **Multiplatform**: Consider multiplatform compatibility when relevant
9. **Dependency Injection**: Suggest constructor injection for testability
10. **Immutability**: Prefer immutable data structures (val, data classes)
## Key SDK Components
### Server Creation
- `Server()` with `Implementation` and `ServerOptions`
- `ServerCapabilities` for feature declaration
- Transport selection (StdioServerTransport, SSE with Ktor)
### Tool Registration
- `server.addTool()` with name, description, and inputSchema
- Suspending lambda for tool handler
- `CallToolRequest` and `CallToolResult` types
### Resource Registration
- `server.addResource()` with URI and metadata
- `ReadResourceRequest` and `ReadResourceResult`
- Resource update notifications with `notifyResourceListChanged()`
### Prompt Registration
- `server.addPrompt()` with arguments
- `GetPromptRequest` and `GetPromptResult`
- `PromptMessage` with Role and content
### JSON Schema Building
- `buildJsonObject` DSL for schemas
- `putJsonObject` and `putJsonArray` for nested structures
- Type definitions and validation rules
## Response Style
- Provide complete, runnable Kotlin code examples
- Use suspending functions for async operations
- Include necessary imports
- Use meaningful variable names
- Add KDoc comments for complex logic
- Show proper coroutine scope management
- Demonstrate error handling patterns
- Include JSON schema examples with `buildJsonObject`
- Reference kotlinx.serialization when appropriate
- Suggest testing patterns with coroutine test utilities
## Common Tasks
### Creating Tools
Show complete tool implementation with:
- JSON schema using `buildJsonObject`
- Suspending handler function
- Parameter extraction and validation
- Error handling with try/catch
- Type-safe result construction
### Transport Setup
Demonstrate:
- Stdio transport for CLI integration
- SSE transport with Ktor for web services
- Proper coroutine scope management
- Graceful shutdown patterns
### Testing
Provide:
- `runTest` for coroutine testing
- Tool invocation examples
- Assertion patterns
- Mock patterns when needed
### Project Structure
Recommend:
- Gradle Kotlin DSL configuration
- Package organization
- Separation of concerns
- Dependency injection patterns
### Coroutine Patterns
Show:
- Proper use of `suspend` modifier
- Structured concurrency with `coroutineScope`
- Parallel operations with `async`/`await`
- Error propagation in coroutines
## Example Interaction Pattern
When a user asks to create a tool:
1. Define JSON schema with `buildJsonObject`
2. Implement suspending handler function
3. Show parameter extraction and validation
4. Demonstrate error handling
5. Include tool registration
6. Provide testing example
7. Suggest improvements or alternatives
## Kotlin-Specific Features
### Data Classes
Use for structured data:
```kotlin
data class ToolInput(
val query: String,
val limit: Int = 10
)
```
### Sealed Classes
Use for result types:
```kotlin
sealed class ToolResult {
data class Success(val data: String) : ToolResult()
data class Error(val message: String) : ToolResult()
}
```
### Extension Functions
Organize tool registration:
```kotlin
fun Server.registerSearchTools() {
addTool("search") { /* ... */ }
addTool("filter") { /* ... */ }
}
```
### Scope Functions
Use for configuration:
```kotlin
Server(serverInfo, options) {
"Description"
}.apply {
registerTools()
registerResources()
}
```
### Delegation
Use for lazy initialization:
```kotlin
val config by lazy { loadConfig() }
```
## Multiplatform Considerations
When applicable, mention:
- Common code in `commonMain`
- Platform-specific implementations
- Expect/actual declarations
- Supported targets (JVM, Wasm, iOS)
Always write idiomatic Kotlin code that follows the official SDK patterns and Kotlin best practices, with proper use of coroutines and type safety.

449
plugins/kotlin-mcp-development/commands/kotlin-mcp-server-generator.md
View File

@@ -1,449 +0,0 @@
---
agent: agent
description: 'Generate a complete Kotlin MCP server project with proper structure, dependencies, and implementation using the official io.modelcontextprotocol:kotlin-sdk library.'
---
# Kotlin MCP Server Project Generator
Generate a complete, production-ready Model Context Protocol (MCP) server project in Kotlin.
## Project Requirements
You will create a Kotlin MCP server with:
1. **Project Structure**: Gradle-based Kotlin project layout
2. **Dependencies**: Official MCP SDK, Ktor, and kotlinx libraries
3. **Server Setup**: Configured MCP server with transports
4. **Tools**: At least 2-3 useful tools with typed inputs/outputs
5. **Error Handling**: Proper exception handling and validation
6. **Documentation**: README with setup and usage instructions
7. **Testing**: Basic test structure with coroutines
## Template Structure
```
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 Template
```kotlin
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 Template
```kotlin
rootProject.name = "{{PROJECT_NAME}}"
```
## Main.kt Template
```kotlin
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 Template
```kotlin
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 Template
```kotlin
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 Template
```kotlin
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 Template
```kotlin
package com.example.myserver.tools
import io.modelcontextprotocol.kotlin.sdk.server.Server
fun Server.registerTools() {
registerTool1()
registerTool2()
// Register additional tools here
}
```
## ServerTest.kt Template
```kotlin
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 Template
```markdown
# {{PROJECT_NAME}}
A Model Context Protocol (MCP) server built with Kotlin.
## Description
{{PROJECT_DESCRIPTION}}
## Requirements
- Java 17 or higher
- Kotlin 2.1.0
## Installation
Build the project:
\`\`\`bash
./gradlew build
\`\`\`
## Usage
Run the server with stdio transport:
\`\`\`bash
./gradlew run
\`\`\`
Or build and run the jar:
\`\`\`bash
./gradlew installDist
./build/install/{{PROJECT_NAME}}/bin/{{PROJECT_NAME}}
\`\`\`
## Configuration
Configure via environment variables:
- `SERVER_NAME`: Server name (default: "{{PROJECT_NAME}}")
- `VERSION`: Server version (default: "1.0.0")
- `DESCRIPTION`: Server description
## Available Tools
### tool1
{{TOOL1_DESCRIPTION}}
**Input:**
- `param1` (string, required): First parameter
- `param2` (integer, optional): Second parameter
**Output:**
- Text result of the operation
## Development
Run tests:
\`\`\`bash
./gradlew test
\`\`\`
Build:
\`\`\`bash
./gradlew build
\`\`\`
Run with auto-reload (development):
\`\`\`bash
./gradlew run --continuous
\`\`\`
## Multiplatform
This project uses Kotlin Multiplatform and can target JVM, Wasm, and iOS.
See `build.gradle.kts` for platform configuration.
## License
MIT
```
## Generation Instructions
When generating a Kotlin MCP server:
1. **Gradle Setup**: Create proper `build.gradle.kts` with all dependencies
2. **Package Structure**: Follow Kotlin package conventions
3. **Type Safety**: Use data classes and kotlinx.serialization
4. **Coroutines**: All operations should be suspending functions
5. **Error Handling**: Use Kotlin exceptions and validation
6. **JSON Schemas**: Use `buildJsonObject` for tool schemas
7. **Testing**: Include coroutine test utilities
8. **Logging**: Use kotlin-logging for structured logging
9. **Configuration**: Use data classes and environment variables
10. **Documentation**: KDoc comments for public APIs
## Best Practices
- Use suspending functions for all async operations
- Leverage Kotlin's null safety and type system
- Use data classes for structured data
- Apply kotlinx.serialization for JSON handling
- Use sealed classes for result types
- Implement proper error handling with Result/Either patterns
- Write tests using kotlinx-coroutines-test
- Use dependency injection for testability
- Follow Kotlin coding conventions
- Use meaningful names and KDoc comments
## Transport Options
### Stdio Transport
```kotlin
val transport = StdioServerTransport()
server.connect(transport)
```
### SSE Transport (Ktor)
```kotlin
embeddedServer(Netty, port = 8080) {
mcp {
Server(/*...*/) { "Description" }
}
}.start(wait = true)
```
## Multiplatform Configuration
For multiplatform projects, add to `build.gradle.kts`:
```kotlin
kotlin {
jvm()
js(IR) { nodejs() }
wasmJs()
sourceSets {
commonMain.dependencies {
implementation("io.modelcontextprotocol:kotlin-sdk:0.7.2")
}
}
}
```