Blog
Punto de vista

¿Qué son los servidores MCP? Explicado claramente

¿Qué son los Servidores MCP y por qué todos hablan de ellos? ¡Descúbrelo aquí!

Daniel Costa

Daniel Costa

15 April 2025

¿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.

💡
¿Necesitas encontrar la mejor herramienta alternativa a Postman que integre todo tu flujo de trabajo de pruebas de API en un solo lugar?
Descarga Apidog gratis hoy mismo y descubre cómo puede transformar tu flujo de trabajo.
button

¿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.

Fuente: Blog de Norah Sakal

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:

Fuente: Tahir

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:

💡
¿Quieres explorar más de 1000 servidores MCP?

¡Obtén más información en Himcp.ai!
button

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

Fuente: Blog de Norah Sakal

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:

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:

Configurando Tu Entorno

Antes de empezar, asegúrate de tener:

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:

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:

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:

Ejemplos de indicaciones:

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:

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.

button


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.


Explore more

Cómo usar Ollama: Guía Completa para Principiantes sobre LLMs Locales con Ollama

Cómo usar Ollama: Guía Completa para Principiantes sobre LLMs Locales con Ollama

El panorama de la inteligencia artificial evoluciona constantemente, y los Grandes Modelos de Lenguaje (LLM) se vuelven cada vez más potentes y accesibles. Aunque muchos interactúan con estos modelos a través de servicios basados en la nube, existe un movimiento creciente enfocado en ejecutarlos directamente en computadoras personales. Aquí es donde entra Ollama. Ollama es una herramienta potente pero fácil de usar, diseñada para simplificar drásticamente el complejo proceso de descargar, config

28 April 2025

¿Dónde Descargar Swagger UI en Español Gratis?

¿Dónde Descargar Swagger UI en Español Gratis?

¿Necesitas Swagger UI en español? Este artículo explica por qué no existe una descarga oficial gratuita y cómo habilitar la traducción. Explora las características de Swagger y por qué Apidog es la alternativa superior para diseño, pruebas y documentación API integrados.

23 April 2025

¿Dónde Descargar Postman en Español Gratis?

¿Dónde Descargar Postman en Español Gratis?

¿Puedes descargar Postman en español gratis? Aunque Postman carece de soporte nativo en español, existen soluciones. Explóralas y descubre Apidog, una potente alternativa unificada a Postman diseñada para optimizar todo tu flujo de trabajo de API, sin importar el idioma.

22 April 2025

Practica el diseño de API en Apidog

Descubre una forma más fácil de construir y usar APIs

Registrarse gratisDescargar