SDKs Oficiales MCP

Elige el SDK que mejor se adapte a tu stack tecnológico. Todos los SDKs oficiales proporcionan soporte completo para recursos, herramientas y prompts.

Python SDK

v1.0.0+

SDK oficial para Python 3.11+. Ideal para servidores MCP en Python, con soporte completo para recursos, herramientas y prompts.

Instalación:

pip install mcp

Requisitos:

Python 3.11 o superior

Características:

Soporte completo para recursos, herramientas y prompts
Decoradores intuitivos para definir handlers
Tipos fuertemente tipados con type hints
Transporte stdio y SSE incluido
Excelente documentación y ejemplos

Ver documentación

TypeScript SDK

v1.0.0+

SDK oficial para Node.js y TypeScript. Perfecto para servidores MCP en el ecosistema JavaScript/TypeScript.

Instalación:

npm install @model-context-protocol/sdk

Requisitos:

Node.js 18+ o superior

Características:

TypeScript completo con tipos estrictos
Soporte para ESM y CommonJS
Transporte stdio y SSE
Compatibilidad con Node.js y Deno
Integración con frameworks modernos

Ver documentación

Kotlin SDK

v1.0.0+

SDK oficial para Kotlin/JVM. Permite crear servidores MCP en Kotlin para aplicaciones Android y backend.

Instalación:

implementation("com.anthropic:mcp-sdk:1.0.0")

Requisitos:

Kotlin 1.9+ / JVM 11+

Características:

Soporte completo para JVM y Android
Coroutines para operaciones asíncronas
Tipos seguros con Kotlin
Integración con Spring Boot
Excelente rendimiento y concurrencia

Ver documentación

Guías de Instalación

Sigue estos pasos detallados para instalar y configurar cada SDK.

Instalación: Python SDK

Verifica la versión de Python

Asegúrate de tener Python 3.11 o superior instalado.

python --version

Instala el SDK

Instala el paquete oficial de MCP desde PyPI.

pip install mcp

Verifica la instalación

Confirma que la instalación fue exitosa.

python -c "import mcp; print(mcp.__version__)"

Instalación: TypeScript SDK

Verifica la versión de Node.js

Asegúrate de tener Node.js 18 o superior instalado.

node --version

Crea un proyecto (opcional)

Inicializa un nuevo proyecto Node.js si es necesario.

npm init -y

Instala el SDK

Instala el paquete oficial de MCP desde npm.

npm install @model-context-protocol/sdk

Configura TypeScript (opcional)

Instala TypeScript y tipos de Node.js para desarrollo.

npm install -D typescript @types/node

Instalación: Kotlin SDK

Configura Gradle

Añade la dependencia en tu archivo build.gradle.kts.

build.gradle.kts

Añade la dependencia

Incluye el SDK de MCP en las dependencias de tu proyecto.

implementation("com.anthropic:mcp-sdk:1.0.0")

Sincroniza el proyecto

Sincroniza y construye el proyecto para descargar las dependencias.

./gradlew build

Ejemplo de build.gradle.kts:

dependencies {
    implementation("com.anthropic:mcp-sdk:1.0.0")
    // Otras dependencias...
}

Ejemplos de Uso

Aquí tienes ejemplos básicos de cómo usar cada SDK para crear un servidor MCP simple.

Ejemplo: Python SDK

Servidor básico con una herramienta "hello"

from mcp.server import Server
from mcp.types import Tool, TextContent
import mcp.types as types

app = Server("mi-servidor")

@app.list_tools()
async def list_tools() -> list[Tool]:
    return [
        Tool(
            name="hello",
            description="Saluda al usuario",
            inputSchema={
                "type": "object",
                "properties": {
                    "name": {"type": "string"}
                }
            }
        )
    ]

@app.call_tool()
async def call_tool(name: str, arguments: dict) -> list[TextContent]:
    if name == "hello":
        name = arguments.get("name", "Mundo")
        return [TextContent(
            type="text",
            text=f"¡Hola, {name}!"
        )]
    raise ValueError(f"Tool desconocida: {name}")

if __name__ == "__main__":
    from mcp.server.stdio import stdio_server
    stdio_server(app)

Ejemplo: TypeScript SDK

Servidor básico con una herramienta "hello"

import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import {
  CallToolRequestSchema,
  ListToolsRequestSchema,
} from "@modelcontextprotocol/sdk/types.js";

const server = new Server(
  {
    name: "mi-servidor",
    version: "0.1.0",
  },
  {
    capabilities: {
      tools: {},
    },
  }
);

server.setRequestHandler(ListToolsRequestSchema, async () => ({
  tools: [
    {
      name: "hello",
      description: "Saluda al usuario",
      inputSchema: {
        type: "object",
        properties: {
          name: { type: "string" },
        },
      },
    },
  ],
}));

server.setRequestHandler(CallToolRequestSchema, async (request) => {
  if (request.params.name === "hello") {
    const name = request.params.arguments?.name || "Mundo";
    return {
      content: [
        {
          type: "text",
          text: `¡Hola, ${name}!`,
        },
      ],
    };
  }
  throw new Error(`Tool desconocida: ${request.params.name}`);
});

async function main() {
  const transport = new StdioServerTransport();
  await server.connect(transport);
}

main();

Ejemplo: Kotlin SDK

Servidor básico con una herramienta "hello"

import com.anthropic.mcp.server.Server
import com.anthropic.mcp.types.Tool
import com.anthropic.mcp.types.TextContent
import kotlinx.coroutines.flow.flow

val server = Server(
    name = "mi-servidor",
    version = "0.1.0"
)

server.listTools { 
    listOf(
        Tool(
            name = "hello",
            description = "Saluda al usuario",
            inputSchema = mapOf(
                "type" to "object",
                "properties" to mapOf(
                    "name" to mapOf("type" to "string")
                )
            )
        )
    )
}

server.callTool { request ->
    when (request.name) {
        "hello" -> {
            val name = request.arguments?.get("name") as? String ?: "Mundo"
            listOf(
                TextContent(
                    type = "text",
                    text = "¡Hola, $name!"
                )
            )
        }
        else -> throw IllegalArgumentException("Tool desconocida: ${request.name}")
    }
}

fun main() {
    server.start()
}

¿Cuál SDK Elegir?

Python SDK

Elige Python si ya trabajas con Python, necesitas integración con bibliotecas científicas, o prefieres una sintaxis clara y legible.

TypeScript SDK

Elige TypeScript si trabajas con Node.js, necesitas integración con el ecosistema JavaScript, o desarrollas aplicaciones web modernas.

Kotlin SDK

Elige Kotlin si desarrollas para Android, trabajas con JVM, o necesitas integración con Spring Boot.

¿Listo para empezar?

Explora más recursos, tutoriales y ejemplos para dominar MCP.

Ver Quickstart Ver Tutoriales Crear Servidores