Refactor dokka configuration

- remove docs gradle module
- remove trigger docs on push
- add main page for dokka documentation

Author: devcrocod

.github/workflows/apidocs.yaml

@@ -4,8 +4,6 @@ on:
   release:
     types:
       - published
-  push:
-    branches: [ "main" ]
   # Allow running this workflow manually from the Actions tab
   workflow_dispatch:
 
@@ -35,7 +33,7 @@ jobs:
           cache: gradle
 
       - name: Setup Gradle
-        uses: gradle/actions/setup-gradle@ed408507eac070d1f99cc633dbcf757c94c7933a # v4.4.3
+        uses: gradle/actions/setup-gradle@v4
 
       - name: Generate Dokka Site
         run: |-
@@ -44,7 +42,7 @@ jobs:
       - name: Upload artifact
         uses: actions/upload-pages-artifact@v4
         with:
-          path: docs/build/dokka/html
+          path: build/dokka/html
 
       - name: Deploy to GitHub Pages
         id: deployment

.idea/icon.png

@@ -1,4 +1,5 @@
 plugins {
+    id("mcp.dokka")
     alias(libs.plugins.ktlint)
     alias(libs.plugins.kover)
 }
@@ -9,6 +10,10 @@ allprojects {
 }
 
 dependencies {
+    dokka(project(":kotlin-sdk-core"))
+    dokka(project(":kotlin-sdk-client"))
+    dokka(project(":kotlin-sdk-server"))
+
     kover(project(":kotlin-sdk-core"))
     kover(project(":kotlin-sdk-client"))
     kover(project(":kotlin-sdk-server"))
@@ -20,6 +25,14 @@ subprojects {
     apply(plugin = "org.jetbrains.kotlinx.kover")
 }
 
+dokka {
+    moduleName = "MCP Kotlin SDK"
+
+    dokkaPublications.html {
+        includes.from("docs/moduledoc.md")
+    }
+}
+
 kover {
     reports {
         filters {

build.gradle.kts

@@ -0,0 +1,103 @@
+# MCP Kotlin SDK
+
+Kotlin SDK for the Model Context Protocol (MCP).
+This is a Kotlin Multiplatform library that helps you build MCP clients and servers that speak the same protocol and
+share the same types.
+The SDK focuses on clarity, small building blocks, and first‑class coroutine support.
+
+Use the umbrella `kotlin-sdk` artifact when you want a single dependency that brings the core types plus both client and
+server toolkits. If you only need one side, depend on `kotlin-sdk-client` or `kotlin-sdk-server` directly.
+
+Gradle (Kotlin DSL):
+
+```kotlin
+dependencies {
+    // Convenience bundle with everything you need to start
+    implementation("io.modelcontextprotocol:kotlin-sdk:<version>")
+
+    // Or pick modules explicitly
+    implementation("io.modelcontextprotocol:kotlin-sdk-client:<version>")
+    implementation("io.modelcontextprotocol:kotlin-sdk-server:<version>")
+}
+```
+
+---
+
+## Module kotlin-sdk-core
+
+Foundational, platform‑agnostic pieces:
+
+- Protocol data model and JSON serialization (kotlinx.serialization)
+- Request/response and notification types used by both sides of MCP
+- Coroutine‑friendly protocol engine and utilities
+- Transport abstractions shared by client and server
+
+You typically do not use `core` directly in application code; it is pulled in by the client/server modules. Use it
+explicitly if you only need the protocol types or plan to implement a custom transport.
+
+---
+
+## Module kotlin-sdk-client
+
+High‑level client API for connecting to an MCP server and invoking its tools, prompts, and resources. Ships with several
+transports:
+
+- WebSocketClientTransport – low latency, full‑duplex
+- SSEClientTransport – Server‑Sent Events over HTTP
+- StdioClientTransport – CLI‑friendly stdio bridge
+- StreamableHttpClientTransport – simple HTTP streaming
+
+A minimal client:
+
+```kotlin
+val client = Client(
+    clientInfo = Implementation(name = "sample-client", version = "1.0.0")
+)
+
+client.connect(WebSocketClientTransport("ws://localhost:8080/mcp"))
+
+val tools = client.listTools()
+val result = client.callTool(
+    name = "echo",
+    arguments = mapOf("text" to "Hello, MCP!")
+)
+```
+
+---
+
+## Module kotlin-sdk-server
+
+Lightweight server toolkit for hosting MCP tools, prompts, and resources. It provides a small, composable API and
+ready‑to‑use transports:
+
+- StdioServerTransport – integrates well with CLIs and editors
+- SSE/WebSocket helpers for Ktor – easy HTTP deployment
+
+Register tools and run over stdio:
+
+```kotlin
+
+val server = Server(
+    serverInfo = Implementation(name = "sample-server", version = "1.0.0"),
+    options = ServerOptions(ServerCapabilities())
+)
+
+server.addTool(
+    name = "echo",
+    description = "Echoes the provided text"
+) { request ->
+    // Build and return a CallToolResult from request.arguments
+    // (see CallToolResult and related types in kotlin-sdk-core)
+    /* ... */
+}
+
+// Bridge the protocol over stdio
+val transport = StdioServerTransport(
+    inputStream = kotlinx.io.files.Path("/dev/stdin").source(),
+    outputStream = kotlinx.io.files.Path("/dev/stdout").sink()
+)
+// Start transport and wire it with the server using provided helpers in the SDK.
+```
+
+For HTTP deployments, use the Ktor extensions included in the module to expose an MCP WebSocket or SSE endpoint with a
+few lines of code.

docs/build.gradle.kts

@@ -1,7 +1,6 @@
 plugins {
     id("mcp.multiplatform")
     id("mcp.publishing")
-    id("mcp.dokka")
     id("mcp.jreleaser")
 }
 

docs/icon.png

@@ -23,7 +23,6 @@ include(
     ":kotlin-sdk-server",
     ":kotlin-sdk",
     ":kotlin-sdk-test",
-    ":docs",
 )
 
 // Include sample projects as composite builds