MCPExpert

Quickstart MCP

Empieza a usar el Model Context Protocol en minutos. Elige tu camino según tu rol.

Para usuarios de Claude Desktop

Conecta servidores MCP existentes con Claude Desktop en minutos

5 min
Paso 1

Instala Claude Desktop

Descarga e instala Claude Desktop desde el sitio oficial de Anthropic.

Paso 2

Configura un servidor MCP

Elige un servidor de nuestro directorio y sigue las instrucciones de instalación.

Paso 3

Edita la configuración

Añade el servidor a tu archivo de configuración de Claude Desktop.

Paso 4

¡Empieza a usar!

Reinicia Claude Desktop y pregunta a Claude sobre tus datos.

Ejemplo de configuración

Edita tu archivo de configuración de Claude Desktop (ubicación varía según el SO):

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "/path/to/allowed/directory"
      ]
    }
  }
}
Ver servidores disponibles

Para desarrolladores de servidores

Crea servidores MCP que expongan tus datos y herramientas a LLMs

15 min
Paso 1

Instala el SDK

Elige Python o TypeScript según tu preferencia.

Paso 2

Crea tu primer servidor

Define recursos, herramientas o prompts que quieres exponer.

Paso 3

Prueba localmente

Usa el inspector MCP o herramientas de debugging para validar.

Paso 4

Comparte con la comunidad

Publica tu servidor en GitHub y añádelo a nuestro directorio.

Ejemplo rápido: Servidor Python

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="get_weather",
            description="Obtiene el clima actual",
            inputSchema={
                "type": "object",
                "properties": {
                    "city": {"type": "string"}
                },
                "required": ["city"]
            }
        )
    ]

@app.call_tool()
async def call_tool(name: str, arguments: dict) -> list[TextContent]:
    if name == "get_weather":
        city = arguments.get("city", "Madrid")
        return [TextContent(
            type="text",
            text=f"El clima en {city} es soleado, 22°C"
        )]
    raise ValueError(f"Tool desconocida: {name}")

if __name__ == "__main__":
    from mcp.server.stdio import stdio_server
    stdio_server(app)
pip install mcpVer más ejemplos

Ejemplo rápido: Servidor TypeScript

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: "get_weather",
      description: "Obtiene el clima actual",
      inputSchema: {
        type: "object",
        properties: {
          city: { type: "string" },
        },
        required: ["city"],
      },
    },
  ],
}));

server.setRequestHandler(CallToolRequestSchema, async (request) => {
  if (request.params.name === "get_weather") {
    const city = request.params.arguments?.city || "Madrid";
    return {
      content: [
        {
          type: "text",
          text: `El clima en ${city} es soleado, 22°C`,
        },
      ],
    };
  }
  throw new Error(`Tool desconocida: ${request.params.name}`);
});

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

main();
npm install @model-context-protocol/sdkVer tutoriales completos

Para desarrolladores de clientes

Construye aplicaciones que se conecten con servidores MCP

20 min
Paso 1

Instala el SDK del cliente

Usa el SDK de TypeScript o Python para crear tu cliente MCP.

Paso 2

Conecta con servidores

Establece conexiones con uno o múltiples servidores MCP.

Paso 3

Implementa la lógica

Integra las herramientas y recursos en tu aplicación.

Paso 4

Despliega tu cliente

Conecta tu aplicación con los servidores MCP disponibles.

Ejemplo: Cliente TypeScript

import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";

const client = new Client(
  {
    name: "mi-cliente",
    version: "0.1.0",
  },
  {
    capabilities: {},
  }
);

async function main() {
  const transport = new StdioClientTransport({
    command: "python",
    args: ["-m", "mi_servidor"],
  });

  await client.connect(transport);

  // Listar herramientas disponibles
  const tools = await client.listTools();
  console.log("Herramientas disponibles:", tools);

  // Llamar a una herramienta
  const result = await client.callTool({
    name: "get_weather",
    arguments: { city: "Barcelona" },
  });

  console.log("Resultado:", result);
}

main().catch(console.error);
npm install @model-context-protocol/sdkVer más ejemplos de clientes

¿Necesitas más ayuda?

Explora nuestra documentación completa, tutoriales y ejemplos de la comunidad.

Ver DocumentaciónExplorar TutorialesPreguntas Frecuentes