¿Qué son los servidores MCP? Explicado claramente

El Protocolo de Contexto del Modelo (MCP), presentado por Anthropic el 26 de noviembre de 2024, es un estándar abierto destinado a cerrar la brecha entre los modelos de IA y las fuentes de datos externas. Este protocolo aborda un desafío crítico: incluso los Modelos de Lenguaje Grande (LLM) avanzados, aunque potentes en la generación de texto, a menudo están aislados de los datos y herramientas en tiempo real, lo que limita su utilidad práctica. Los Servidores MCP, como componentes integrales, permiten que los asistentes de IA como Claude accedan a archivos, bases de datos, API y más, mejorando su capacidad para ofrecer respuestas relevantes y prácticas.

La importancia de MCP radica en su potencial para estandarizar las integraciones, reduciendo la fragmentación que ha afectado el desarrollo de la IA. Al proporcionar un protocolo universal, su objetivo es ayudar a los modelos de vanguardia a producir respuestas mejores y más relevantes al derribar los silos de información y las barreras de los sistemas heredados.

A partir del 25 de marzo de 2025, el ecosistema está creciendo rápidamente, con contribuciones de la comunidad y adopciones empresariales, como los primeros usuarios como Block y Apollo que integran MCP en sus sistemas.

¿Qué son los Servidores MCP?

Los servidores MCP, que forman parte del Protocolo de Contexto del Modelo (MCP), son programas especiales que ayudan a los modelos de IA, como los de Anthropic, a conectarse y utilizar datos y herramientas externas. Introducidos en noviembre de 2024, permiten que la IA haga algo más que generar texto al acceder a cosas como archivos en tu ordenador, bases de datos o incluso servicios como GitHub, todo de una manera segura y estandarizada.

Piensa en los servidores MCP como puentes que permiten que la IA interactúe con el mundo exterior, de forma similar a como los puertos USB te permiten conectar diferentes dispositivos a tu ordenador. Por ejemplo, si le pides a una IA que resuma un documento, puede extraer el archivo directamente de tu sistema. O, si necesitas crear un problema en GitHub, la IA también puede hacerlo, gracias a un servidor MCP. Pueden proporcionar datos (como archivos), herramientas (como llamadas a la API) o indicaciones (guías para la interacción), lo que hace que la IA sea más útil para tareas como la codificación, la investigación o la gestión de proyectos.

Un detalle inesperado es la rapidez con la que ha crecido la comunidad, con más de 250 servidores ya disponibles, incluyendo tanto integraciones oficiales como contribuciones de la comunidad, lo que demuestra un ecosistema vibrante que se está expandiendo rápidamente.

Cómo Funcionan los Servidores MCP (Y en Qué se Diferencian de las API)

MCP opera en un modelo cliente-servidor, como se describe en la documentación. La arquitectura incluye:

• Hosts MCP: Aplicaciones como Claude Desktop, IDEs o herramientas de IA que buscan aprovechar datos externos.
• Clientes MCP: Clientes de protocolo que mantienen conexiones seguras, uno a uno, con los servidores, garantizando una comunicación eficiente.
• Servidores MCP: Programas ligeros que exponen cada uno capacidades específicas a través del Protocolo de Contexto del Modelo estandarizado. Esta estructura permite una integración perfecta, con hosts que utilizan clientes para conectarse a varios servidores, cada uno de los cuales ofrece funcionalidades únicas. El protocolo admite tres tipos principales de exposiciones:
• Recursos: Fuentes de datos como archivos, documentos o consultas de bases de datos que la IA puede cargar en su contexto. Por ejemplo, un servidor de sistema de archivos podría permitir el acceso a documentos locales.
• Herramientas: Acciones que la IA puede realizar, como realizar llamadas a la API o ejecutar comandos. Un ejemplo es un servidor GitHub que permite la gestión de repositorios, detallado en el mismo repositorio.
• Indicaciones: Plantillas reutilizables para las interacciones LLM, que guían el comportamiento de la IA en escenarios específicos.

El protocolo se basa en JSON-RPC 2.0, lo que garantiza conexiones con estado y la negociación de capacidades entre clientes y servidores. Esta base técnica permite una comunicación robusta y segura, con características como el seguimiento del progreso, la cancelación y la notificación de errores que mejoran la fiabilidad.

Entonces, ¿Qué Pueden Hacer Realmente los MCP?

Los servidores MCP están diseñados para ser versátiles, atendiendo a una amplia gama de necesidades. Se pueden ejecutar localmente o de forma remota, dependiendo de la implementación, y están construidos con principios de seguridad primero. Cada servidor controla sus propios recursos, manteniendo límites claros del sistema para evitar el acceso no autorizado.

Esta seguridad es crucial, especialmente cuando se trata de datos sensibles, asegurando que las conexiones sean seguras y que los permisos se gestionen de forma estricta.

Técnicamente, los servidores exponen sus capacidades a través de puntos finales JSON-RPC, lo que permite a los clientes consultar los recursos, herramientas e indicaciones disponibles.

Por ejemplo, un servidor podría exponer un recurso "readFile" que devuelve el contenido de un archivo especificado, o una herramienta "createIssue" que interactúa con la API de GitHub. El protocolo también admite comportamientos iniciados por el servidor, como el muestreo, lo que permite interacciones de IA agentic, que pueden ser recursivas y dinámicas, como se describe en la especificación.

¿Interesado en los Servidores MCP? Puedes Probar Estos Ahora

El ecosistema de servidores MCP es rico y está creciendo, con numerosos ejemplos que ilustran su utilidad, como se enumera en el repositorio en GitHub - awesome-mcp-servers:

• Servidor MCP del Sistema de Archivos: Permite a la IA leer y escribir archivos, útil para acceder a notas o scripts personales, como se ve en la implementación de referencia en GitHub - filesystem.
• Servidor MCP de GitHub: Facilita interacciones como la creación de problemas o la confirmación de código, mejorando los flujos de trabajo de los desarrolladores, detallado en GitHub - github.
• Servidor MCP de Web Scraping: Permite a la IA buscar y extraer contenido web, proporcionando datos en tiempo real, como se menciona en los servidores de la comunidad como tavily-ai/tavily-mcp.
• Servidores MCP de Bases de Datos: Ofrecen acceso a bases de datos SQL o NoSQL, como PostgreSQL o MongoDB, lo que permite consultas de datos, como se ve en GitHub - postgres.
• Servidores MCP de Integración de API: Se conectan a servicios como Slack, Trello o API del tiempo, ampliando la base de conocimientos de la IA, con ejemplos como GitHub - slack. Estos servidores demuestran la flexibilidad del protocolo, con contribuciones de la comunidad como los servidores de gestión de Kubernetes que se añaden al ecosistema, como se enumera en los servidores de terceros en GitHub - servers.

¿Cuál es la Diferencia Entre un Servidor MCP y las API?

Si bien tanto los servidores MCP como las API tradicionales permiten que el software interactúe con servicios externos, sus propósitos difieren en el contexto de la IA:

• Propósito: Las API tradicionales son interfaces de propósito general para la comunicación de software, que a menudo se utilizan para enviar consultas a modelos de IA o acceder a servicios externos. Los servidores MCP están diseñados específicamente para proporcionar contexto a los modelos de IA, con un enfoque en datos, herramientas e indicaciones en un formato estandarizado.
• Interacción: Con una API tradicional, el modelo de IA necesita saber cómo llamar a la API, analizar su respuesta e integrar esa información en su contexto. Con un servidor MCP, el servidor gestiona la interacción con la fuente de datos o la herramienta y presenta la información de una manera que el modelo de IA puede entender y utilizar fácilmente, sin necesidad de conocer los detalles de la fuente de datos subyacente.
• Estandarización: MCP proporciona un protocolo estandarizado, lo que lo hace plug-and-play para varios servidores, mientras que las API tradicionales pueden requerir una integración personalizada para cada servicio.
• Seguridad: Los servidores MCP están optimizados para la seguridad, con autenticación integrada y controles de acceso, mientras que las API tradicionales pueden requerir medidas de seguridad adicionales dependiendo de la implementación.

Por ejemplo, en una configuración tradicional, la IA podría necesitar llamar a una API REST para obtener datos meteorológicos, analizar las respuestas JSON e integrarlas en su contexto. Con un servidor MCP, el servidor podría exponer una herramienta "get_weather", y la IA simplemente la llama con parámetros, recibiendo datos formateados listos para su uso.

Cómo Configurar Servidores MCP (con Claude como Ejemplo)

El Protocolo de Contexto del Modelo (MCP) es un marco potente que permite

Los servidores MCP pueden proporcionar tres tipos principales de capacidades:

• Recursos: Datos similares a archivos que pueden ser leídos por los clientes (como respuestas de API o contenidos de archivos)
• Herramientas: Funciones que pueden ser llamadas por el LLM (con la aprobación del usuario)
• Indicaciones: Plantillas preescritas que ayudan a los usuarios a realizar tareas específicas

Configurando Tu Entorno

Antes de empezar, asegúrate de tener:

• Python 3.10 o superior instalado
• Node.js (si utilizas implementaciones de JavaScript/TypeScript)
• Familiaridad básica con la programación en Python o JavaScript
• Comprensión de LLMs como Claude

Instalando el Administrador de Paquetes UV

UV es el administrador de paquetes recomendado para proyectos Python MCP:

# MacOS/Linux
curl -LsSf <https://astral.sh/uv/install.sh> | sh

# Asegúrate de reiniciar tu terminal después

Construyendo un Servidor MCP

Construyamos un servidor meteorológico sencillo como ejemplo.

Este servidor proporcionará dos herramientas: get-alerts y get-forecast.

Paso 1: Configurar la Estructura del Proyecto

# Crea un nuevo directorio para nuestro proyecto
uv init weather
cd weather

# Crea un entorno virtual y actívalo
uv venv
source .venv/bin/activate  # En Windows: .venv\\\\Scripts\\\\activate

# Instala las dependencias
uv add "mcp[cli]" httpx

# Crea nuestro archivo de servidor
touch weather.py

Paso 2: Implementar el Servidor

Aquí tienes una implementación completa de nuestro servidor meteorológico (en weather.py):

from typing import Any
import httpx
from mcpserver.fastmcp import FastMCP

# Inicializa el servidor FastMCP
mcp = FastMCP("weather")

# Constantes
NWS_API_BASE = "<https://api.weather.gov>"
USER_AGENT = "weather-app/1.0"

async def make_nws_request(url: str) -> dict[str, Any] | None:
    """Realiza una solicitud a la API de NWS con el manejo de errores adecuado."""
    headers = {
        "User-Agent": USER_AGENT,
        "Accept": "application/geo+json"
    }
    async with httpx.AsyncClient() as client:
        try:
            response = await client.get(url, headers=headers, timeout=30.0)
            response.raise_for_status()
            return response.json()
        except Exception:
            return None

def format_alert(feature: dict) -> str:
    """Formatea una característica de alerta en una cadena legible."""
    props = feature["properties"]
    return f"""
Evento: {props.get('event', 'Unknown')}
Área: {props.get('areaDesc', 'Unknown')}
Severidad: {props.get('severity', 'Unknown')}
Descripción: {props.get('description', 'No description available')}
Instrucciones: {props.get('instruction', 'No specific instructions provided')}
"""

@mcp.tool()
async def get_alerts(state: str) -> str:
    """Obtén alertas meteorológicas para un estado de EE. UU.

    Args:
        state: Código de estado de EE. UU. de dos letras (por ejemplo, CA, NY)
    """
    url = f"{NWS_API_BASE}/alerts/active/area/{state}"
    data = await make_nws_request(url)

    if not data or "features" not in data:
        return "No se pueden obtener las alertas o no se encontraron alertas."

    if not data["features"]:
        return "No hay alertas activas para este estado."

    alerts = [format_alert(feature) for feature in data["features"]]
    return "\\\\n---\\\\n".join(alerts)

@mcp.tool()
async def get_forecast(latitude: float, longitude: float) -> str:
    """Obtén el pronóstico del tiempo para una ubicación.

    Args:
        latitude: Latitud de la ubicación
        longitude: Longitud de la ubicación
    """
    # Primero obtén el punto final de la cuadrícula de pronóstico
    points_url = f"{NWS_API_BASE}/points/{latitude},{longitude}"
    points_data = await make_nws_request(points_url)

    if not points_data:
        return "No se pueden obtener los datos del pronóstico para esta ubicación."

    # Obtén la URL del pronóstico de la respuesta de los puntos
    forecast_url = points_data["properties"]["forecast"]
    forecast_data = await make_nws_request(forecast_url)

    if not forecast_data:
        return "No se puede obtener el pronóstico detallado."

    # Formatea los períodos en un pronóstico legible
    periods = forecast_data["properties"]["periods"]
    forecasts = []
    for period in periods[:5]:  # Solo muestra los próximos 5 períodos
        forecast = f"""
{period['name']}: Temperatura: {period['temperature']}°{period['temperatureUnit']}
Viento: {period['windSpeed']} {period['windDirection']}
Pronóstico: {period['detailedForecast']}
"""
        forecasts.append(forecast)

    return "\\\\n---\\\\n".join(forecasts)

if __name__ == "__main__":
    # Inicializa y ejecuta el servidor
    mcp.run(transport='stdio')

Paso 3: Ejecuta Tu Servidor

Para probar tu servidor directamente, ejecuta:

uv run weather.py

Conectando a Claude para Escritorio

Claude para Escritorio es una forma sencilla de interactuar con tus servidores MCP.

Paso 1: Instala Claude para Escritorio

Asegúrate de tener Claude para Escritorio instalado y actualizado a la última versión.

Paso 2: Configura Claude para Escritorio

1. Abre la configuración de tu aplicación Claude para Escritorio en un editor de texto:

# macOS
code ~/Library/Application\\\\ Support/Claude/claude_desktop_config.json

2. Añade la configuración de tu servidor:

{
  "mcpServers": {
    "weather": {
      "command": "uv",
      "args": [
        "--directory",
        "/ABSOLUTE/PATH/TO/PARENT/FOLDER/weather",
        "run",
        "weather.py"
      ]
    }
  }
}

Asegúrate de:

• Utilizar la ruta absoluta a tu directorio de servidor
• Asegurarte de que el comando coincida con tu entorno (por ejemplo, uv o la ruta completa a uv)

Paso 3: Reinicia Claude para Escritorio

Después de guardar la configuración, reinicia Claude para Escritorio por completo.

Paso 4: Prueba Tu Servidor

Busca el icono del martillo en la esquina inferior derecha del cuadro de entrada de Claude para Escritorio. Al hacer clic en él, deberían mostrarse las herramientas de tu servidor.

Ahora puedes hacerle a Claude preguntas como:

• "¿Qué tiempo hace en Sacramento?"
• "¿Cuáles son las alertas meteorológicas activas en Texas?"

Construyendo un Cliente MCP Personalizado para Servidores MCP de Claude

En lugar de utilizar Claude para Escritorio, puedes construir tu propio cliente personalizado.

Paso 1: Configurar el Proyecto del Cliente

# Crea el directorio del proyecto
uv init mcp-client
cd mcp-client

# Crea un entorno virtual
uv venv
source .venv/bin/activate  # En Windows: .venv\\\\Scripts\\\\activate

# Instala los paquetes requeridos
uv add mcp anthropic python-dotenv

# Crea nuestro archivo principal
touch client.py

Paso 2: Configura Tu Clave API

Crea un archivo .env con tu clave API de Anthropic:

ANTHROPIC_API_KEY=<tu clave aquí>

Paso 3: Implementar el Cliente

Aquí tienes una implementación básica del cliente (en client.py):

import asyncio
import sys
from typing import Optional
from contextlib import AsyncExitStack

from mcp.client.stdio import ClientSession, StdioServerParameters, stdio_client
from anthropic import Anthropic
from dotenv import load_dotenv

load_dotenv()  # carga las variables de entorno desde .env

class MCPClient:
    def __init__(self):
        # Inicializa los objetos de sesión y cliente
        self.session: Optional[ClientSession] = None
        self.exit_stack = AsyncExitStack()
        self.anthropic = Anthropic()

    async def connect_to_server(self, server_script_path: str):
        """Conéctate a un servidor MCP

        Args:
            server_script_path: Ruta al script del servidor (py o js)
        """
        is_python = server_script_path.endswith('.py')
        is_js = server_script_path.endswith('.js')

        if not (is_python or is_js):
            raise ValueError("El script del servidor debe ser un archivo .py o .js")

        command = "python" if is_python else "node"
        server_params = StdioServerParameters(command=command, args=[server_script_path], env=None)

        stdio_transport = await self.exit_stack.enter_async_context(stdio_client(server_params))
        self.stdio, self.write = stdio_transport
        self.session = await self.exit_stack.enter_async_context(ClientSession(self.stdio, self.write))
        await self.session.initialize()

        # Lista las herramientas disponibles
        response = await self.session.list_tools()
        tools = response.tools
        print("\\\\nConectado al servidor con herramientas:", [tool.name for tool in tools])

    async def process_query(self, query: str) -> str:
        """Procesa una consulta utilizando Claude y las herramientas disponibles"""
        messages = [
            {
                "role": "user",
                "content": query
            }
        ]

        response = await self.session.list_tools()
        available_tools = [{
            "name": tool.name,
            "description": tool.description,
            "input_schema": tool.input_schema
        } for tool in response.tools]

        # Llamada inicial a la API de Claude
        response = self.anthropic.messages.create(
            model="claude-3-5-sonnet-20241022",
            max_tokens=1000,
            messages=messages,
            tools=available_tools
        )

        # Procesa la respuesta y gestiona las llamadas a herramientas
        final_text = []
        assistant_message_content = []

        for content in response.content:
            if content.type == 'text':
                final_text.append(content.text)
                assistant_message_content.append(content)
            elif content.type == 'tool_use':
                tool_name = content.name
                tool_args = content.input

                # Ejecuta la llamada a la herramienta
                result = await self.session.call_tool(tool_name, tool_args)
                final_text.append(f"[Llamando a la herramienta {tool_name} con los argumentos {tool_args}]")
                assistant_message_content.append(content)

                messages.append({
                    "role": "assistant",
                    "content": assistant_message_content
                })

                messages.append({
                    "role": "user",
                    "content": [
                        {
                            "type": "tool_result",
                            "tool_use_id": content.id,
                            "content": result
                        }
                    ]
                })

                # Obtén la siguiente respuesta de Claude
                response = self.anthropic.messages.create(
                    model="claude-3-5-sonnet-20241022",
                    max_tokens=1000,
                    messages=messages,
                    tools=available_tools
                )

                final_text.append(response.content[0].text)

        return "\\\\n".join(final_text)

    async def chat_loop(self):
        """Ejecuta un bucle de chat interactivo"""
        print("\\\\n¡Cliente MCP Iniciado!")
        print("Escribe tus consultas o 'quit' para salir.")

        while True:
            try:
                query = input("\\\\nConsulta: ").strip()
                if query.lower() == 'quit':
                    break

                response = await self.process_query(query)
                print("\\\\n" + response)
            except Exception as e:
                print(f"\\\\nError: {str(e)}")

    async def cleanup(self):
        """Limpia los recursos"""
        await self.exit_stack.aclose()

async def main():
    if len(sys.argv) < 2:
        print("Uso: python client.py <ruta_al_script_del_servidor>")
        sys.exit(1)

    client = MCPClient()

    try:
        await client.connect_to_server(sys.argv[1])
        await client.chat_loop()
    finally:
        await client.cleanup()

if __name__ == "__main__":
    asyncio.run(main())

Paso 4: Ejecuta el Cliente

Para utilizar tu cliente con tu servidor meteorológico:

uv run client.py /path/to/weather.py

Utilizando Servidores MCP Preconstruidos con Claude para Escritorio

Claude para Escritorio admite una variedad de servidores MCP preconstruidos. Veamos cómo utilizar un servidor de sistema de archivos como ejemplo.

Paso 1: Configurar el Servidor del Sistema de Archivos

1. Abre la configuración de Claude para Escritorio y haz clic en "Editar Configuración"
2. Actualiza tu archivo de configuración con:

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "/Users/username/Desktop",
        "/Users/username/Downloads"
      ]
    }
  }
}

Reemplaza username con tu nombre de usuario real y ajusta las rutas según sea necesario.

Paso 2: Reinicia y Prueba

Después de reiniciar Claude para Escritorio, puedes utilizar las herramientas del sistema de archivos para:

• Leer archivos
• Escribir archivos
• Buscar archivos
• Mover archivos

Ejemplos de indicaciones:

• "¿Puedes escribir un poema y guardarlo en mi escritorio?"
• "¿Cuáles son algunos archivos relacionados con el trabajo en mi carpeta de descargas?"
• "¿Puedes tomar todas las imágenes de mi escritorio y moverlas a una nueva carpeta llamada 'Imágenes'?"

Conclusión

Los servidores MCP representan un avance significativo en la funcionalidad de la IA, cerrando la brecha entre los potentes modelos de lenguaje y las herramientas externas. Siguiendo esta guía, has aprendido a crear, configurar y utilizar servidores MCP para mejorar las capacidades de Claude.

El enfoque estandarizado del Protocolo de Contexto del Modelo garantiza que los modelos de IA puedan acceder a datos en tiempo real, realizar acciones e interactuar con los sistemas de forma segura y controlada. Esto hace que los asistentes de IA sean más prácticos para aplicaciones del mundo real en desarrollo, análisis de datos, creación de contenido y más.

A medida que el ecosistema MCP continúa creciendo, los desarrolladores están creando servidores cada vez más sofisticados que amplían lo que es posible con la IA. Ya sea que estés utilizando servidores preconstruidos o desarrollando soluciones personalizadas, MCP proporciona una base flexible para construir aplicaciones de IA más capaces.

A medida que continúas trabajando con servidores MCP que a menudo involucran integraciones de API, es posible que desees explorar Apidog, una plataforma integral de desarrollo de API que puede complementar tu flujo de trabajo de implementación de MCP.

Apidog ofrece una solución todo en uno para el diseño, la documentación, la depuración y las pruebas automatizadas de API. Su interfaz intuitiva facilita:

• Diseñar API con una interfaz visual o importar especificaciones existentes
• Generar automáticamente documentación que se mantenga sincronizada con tu código
• Probar los puntos finales de la API con potentes constructores de solicitudes
• Crear escenarios de prueba automatizados para tus API
• Colaborar con los miembros del equipo a través de espacios de trabajo compartidos

Al desarrollar servidores MCP que interactúan con API externas, Apidog puede ayudarte a validar los puntos finales, comprender las estructuras de respuesta y garantizar que tus integraciones funcionen correctamente antes de implementarlas en el código de tu servidor.

Para comenzar con Apidog junto con tu desarrollo de MCP, visita el sitio web de Apidog y explora cómo puede mejorar tu flujo de trabajo de desarrollo de API.

Al combinar los servidores MCP con herramientas eficientes de desarrollo de API como Apidog, puedes crear conexiones más robustas y fiables entre los sistemas de IA y los servicios externos, haciendo que tus aplicaciones de IA sean aún más potentes.