Model Context Protocol (MCP)

import ai.koog.agents.mcp.McpToolRegistryProvider
import ai.koog.agents.core.agent.AIAgent

// Start an MCP server (e.g., as a Docker container)
val process = ProcessBuilder("docker", "run", "-i", "mcp/google-maps").start()

// Create a ToolRegistry from the MCP server
val toolRegistry = McpToolRegistryProvider.fromTransport(
    transport = McpToolRegistryProvider.defaultStdioTransport(process)
)

// Use the tools in your agent
val agent = AIAgent(
    promptExecutor = executor,
    strategy = strategy,
    agentConfig = agentConfig,
    toolRegistry = toolRegistry
)

agent.run("Get the elevation of Mount Everest")

// Start the MCP server process
val process = ProcessBuilder("path/to/mcp/server").start()

// Create stdio transport
val transport = McpToolRegistryProvider.defaultStdioTransport(process)

// Create tool registry
val toolRegistry = McpToolRegistryProvider.fromTransport(transport)

// Create SSE transport
val transport = McpToolRegistryProvider.defaultSseTransport("http://localhost:8931")

// Or use the convenience method
val toolRegistry = McpToolRegistryProvider.fromSseUrl("http://localhost:8931")

import io.modelcontextprotocol.kotlin.sdk.types.Implementation

val toolRegistry = McpToolRegistryProvider.fromTransport(
    transport = transport,
    serverInfo = McpServerInfo(url = "http://localhost:8931"),
    name = "my-custom-client",
    version = "2.0.0"
)

import io.modelcontextprotocol.kotlin.sdk.client.Client

// Create and configure your client
val mcpClient = Client(clientInfo = Implementation("my-client", "1.0.0"))
mcpClient.connect(transport)

// Create tool registry from the client
val toolRegistry = McpToolRegistryProvider.fromClient(
    mcpClient = mcpClient,
    serverInfo = McpServerInfo(url = "http://localhost:8931")
)

// Start the Docker container
val process = ProcessBuilder(
    "docker", "run", "-i",
    "-e", "GOOGLE_MAPS_API_KEY=$googleMapsApiKey",
    "mcp/google-maps"
).start()

// Create tool registry
val toolRegistry = McpToolRegistryProvider.fromTransport(
    transport = McpToolRegistryProvider.defaultStdioTransport(process)
)

// Create and run the agent
val agent = AIAgent(
    promptExecutor = simpleOpenAIExecutor(openAIApiToken),
    llmModel = OpenAIModels.Chat.GPT4o,
    toolRegistry = toolRegistry,
)

agent.run("Get elevation of the JetBrains Office in Munich, Germany?")

// Start the Playwright MCP server
val process = ProcessBuilder(
    "npx", "@playwright/mcp@latest", "--port", "8931"
).start()

// Create tool registry using SSE
val toolRegistry = McpToolRegistryProvider.fromTransport(
    transport = McpToolRegistryProvider.defaultSseTransport("http://localhost:8931")
)

// Create and run the agent
val agent = AIAgent(
    promptExecutor = simpleOpenAIExecutor(openAIApiToken),
    llmModel = OpenAIModels.Chat.GPT4o,
    toolRegistry = toolRegistry,
)

agent.run("Open a browser, navigate to jetbrains.com, accept cookies, click AI in toolbar")

import ai.koog.ktor.Koog
import io.ktor.server.application.install

fun Application.module() {
    install(Koog) {
        agentConfig {
            mcp {
                // Use SSE transport
                sse("http://localhost:8931")
                
                // Or use process-based transport
                process(yourMcpProcess)
                
                // Or use existing client
                client(yourMcpClient)
            }
        }
    }
}