Las siglas MCP corresponden a la especificación abierta del Protocolo de Contexto de Modelo. Esta especificación define el modo en que los grandes modelos lingüísticos pueden interactuar con herramientas y funciones. Lo más destacado es que las herramientas y los modelos lingüísticos pueden intercambiarse de forma flexible y utilizarse universalmente, ya que hablan el mismo "idioma".
MCP es para las herramientas y los agentes lo que las API REST son para las aplicaciones: un enlace estandarizado para una integración y comunicación perfectas.
¿Qué es el Protocolo de Contexto Modelo (MCP)?
El Protocolo de Contexto de Modelos es una norma técnica abierta publicada por Anthropic. Define cómo los grandes modelos lingüísticos obtienen un contexto específico y acceso a las herramientas y cómo se produce la comunicación entre el modelo lingüístico y la herramienta. Esto permite que el modelo lingüístico recupere exactamente la información, las herramientas y las funcionalidades que el modelo necesita para proporcionar respuestas significativas o completar tareas.
Por tanto, MCP crea una interfaz normalizada que reduce la complejidad. En lugar de crear nuevas soluciones especializadas cada vez, MCP crea orden y reutilización. Ya se trate de acceso a archivos, servicios web o automatización, con MCP muchas cosas pueden vincularse más fácilmente y hacerse utilizables para los LLM.
Por qué es útil el MCP
Los modelos lingüísticos pueden captar el contenido de textos e imágenes y actuar basándose en el conocimiento del modelo lingüístico (conocimiento entrenado). Este conocimiento es una limitación que se alcanza rápidamente. Por ejemplo, un LLM no sabe nada sobre la actualidad, ya que el entrenamiento del modelo lingüístico se completó normalmente meses antes y no se han entrenado eventos actuales, por lo que el LLM no sabe nada sobre las noticias o el tiempo de hoy.
MCP tiene el potencial de colmar esta laguna. Combina un modelo lingüístico con la caja de herramientas adecuada y así puede resolverse la limitación del conocimiento estático.
Por ejemplo, a un modelo lingüístico se le puede dar acceso a un motor de búsqueda y a un servicio meteorológico para que el LLM pueda utilizar activamente estas herramientas para recuperar las últimas noticias o el tiempo de hoy y utilizar esta información. Esta combinación de LLM y herramienta puede utilizarse, por ejemplo, para una actualización matutina diaria en la que el LLM resuma las noticias más importantes y un informe meteorológico para hoy.
Otro caso de uso, algo más especializado pero útil, es la Utilización de un servidor MCP para la optimización de los procesos de archivo.
También en el NLWeb (web en lenguaje natural) el protocolo MCP es un componente integral y juega a su favor.
La arquitectura de MCP
El Protocolo de Contexto de Modelos (MCP) sigue un modelo cliente-servidor típico. La pieza central es el host MCP, un modelo de lenguaje que ejecuta comandos. El cliente MCP actúa como interfaz y reenvía las peticiones entre el modelo y el servidor MCP. Un servidor MCP puede proporcionar diversas herramientas, como funciones, archivos o API. Estas herramientas permiten al modelo acceder a recursos externos como bases de datos o servicios. Las peticiones definen tareas específicas para el modelo, y las herramientas son funciones ejecutables que el modelo puede utilizar para cumplir estas tareas.
- MCP host - el modelo que realiza las tareas
- Cliente MCP - media entre el modelo y el servidor
- Servidor MCP - proporciona herramientas en forma de funciones, archivos o API
- Recursos - Bases de datos, archivos o servicios
- Prompts - tareas preparadas
- Herramientas - Funciones ejecutables
El Protocolo de Contexto Modelo utiliza una estructura cliente-servidor en la que una aplicación central puede comunicarse con varios servidores simultáneamente.
Al igual que USB-C agrupa varias funciones a través de una única conexión, como la carga, los datos y la señal de imagen, MCP conecta modelos con datos, herramientas y servicios a través de una interfaz estandarizada.
Ventajas de la norma MCP
El estándar MCP ofrece una serie de ventajas prácticas que harán que el futuro desarrollo de software basado en LLM sea más eficiente y modular. Esta estandarización permite prescindir de complejas soluciones especiales y de rígidas implementaciones de software, lo que conduce a un desarrollo y uso más ágiles del software.
A continuación se enumeran las principales ventajas de la norma MCP:
- Normalización - El principio de "configurar una vez, usar varias veces" ocupa un lugar central. Al igual que en USB-C, todos los componentes encajan a la perfección, independientemente del fabricante o proveedor. Esta estandarización reduce considerablemente el esfuerzo de integración y favorece la reutilización de módulos y servicios.
- Flexibilidad - Los modelos, herramientas o proveedores pueden intercambiarse parcial o totalmente, ya que todos hablan el mismo "idioma" (MCP). Esta flexibilidad permite adaptarse rápidamente a nuevas necesidades o tecnologías sin tener que rehacer todo el sistema.
- Seguridad - El acceso a herramientas y datos puede controlarse y encapsularse con precisión. Las interfaces y autorizaciones definidas garantizan que sólo los componentes autorizados puedan acceder a información y funciones sensibles.
- Modularidad - Los servidores MCP son bloques de construcción pequeños y autónomos que pueden combinarse, intercambiarse y ampliarse fácilmente. Esta arquitectura modular favorece el desarrollo de sistemas escalables y fáciles de mantener, ya que los componentes individuales pueden actualizarse o sustituirse independientemente unos de otros.
Gracias a estas ventajas, el estándar MCP permite un uso más eficaz, seguro y flexible de las aplicaciones y servicios basados en LLM.
Qué pueden hacer los servidores MCP
En esencia, un servidor MCP amplía el modelo lingüístico con capacidades específicas.
En pocas palabras, los servidores MCP son herramientas que el modelo lingüístico puede utilizar cuando le resulta útil.
Casos de uso típicos que puede cubrir un servidor MCP:
- Acceso a carpetas definidas, archivos o directamente a una base de datos
- Conexión con servicios web como el motor de búsqueda Google
- Uso de aplicaciones como Outlook o Teams
- Aplicación de avisos y flujos de trabajo predefinidos
Ejemplos de servidores MCP populares
La página de Github punkpeye/servidores-mcp-impresionantes enumera muchos servidores útiles que pueden utilizarse inmediatamente.
He aquí algunos ejemplos:
| Servidor MCP | Función |
| sistema de archivos | Acceso a carpetas y archivos locales |
| búsqueda valiente | Búsqueda mediante la Seach API de Brave |
| supabase-mcp | Conexión e interacción con un Supabase Base de datos |
| github-mcp-server | Análisis de código, creación de pull requests o revisiones |
| dramaturgo-mcp | Ofrece funciones de automatización del navegador con Dramaturgo. |
Estos servidores funcionan según el mismo principio que los adaptadores: enchufar y listo.
Esta variedad de servidores MCP demuestra lo flexible y ampliable que es el Protocolo de Contexto de Modelo. La comunidad desarrolla constantemente nuevos servidores que se adaptan a necesidades específicas y amplían las posibilidades de los MCP.
Primeros pasos con los servidores MCP
Para empezar rápidamente
Si sólo quieres empezar, utiliza una aplicación como Claude Desktop. Esto le permite vincular sus propios archivos al modelo. Las instrucciones de modelcontextprotocol.io/quickstart/user ayuda con esto.
He aquí un ejemplo de configuración del claude_desktop_config.json que integra un servidor MCP de Github y Brave Search y lo hace directamente utilizable.
{
"mcpServers": {
"brave-search": {
"command": "docker",
"args": [
"run",
"-i",
"--rm",
"-e",
"BRAVE_API_KEY",
"mcp/brave-search"
],
"env": {
"BRAVE_API_KEY": "YOUR_ACTUAL_BRAVE_API_KEY"
}
},
"github": {
"command": "npx",
"args": [
"-y",
"@modelcontextprotocol/server-github"
],
"env": {
"GITHUB_PERSONAL_ACCESS_TOKEN": "YOUR_ACTUAL_GITHUB_TOKEN"
}
}
}
}
Para los interesados en la tecnología
En Inicio rápido del servidor MCP muestra cómo construir un servidor por ti mismo. Todo lo que necesitas es experiencia en Python o TypeScript, el SDK oficial y un poco de curiosidad.
El siguiente código representa un servidor MCP mínimo que puede ser utilizado por un LLM para convertir correctamente las horas para diferentes zonas horarias.
#!/usr/bin/env python3
"""Minimal MCP-Server - Timezone Converter"""
import json
import sys
from datetime import datetime
import pytz
def convert_timezone(time_str, from_tz, to_tz):
"""Convert time between timezones"""
dt = datetime.strptime(time_str, "%Y-%m-%d %H:%M")
dt_with_tz = pytz.timezone(from_tz).localize(dt)
converted = dt_with_tz.astimezone(pytz.timezone(to_tz))
return {
"original": f"{time_str} {from_tz}",
"converted": f"{converted.strftime('%Y-%m-%d %H:%M')} {to_tz}",
"offset": converted.strftime('%z')
}
def handle_request(request):
"""Route and handle MCP requests"""
method = request["method"]
params = request.get("params", {})
if method == "initialize":
return {
"protocolVersion": "0.1.0",
"capabilities": {"tools": {}},
"serverInfo": {"name": "timezone-converter", "version": "1.0.0"}
}
elif method == "tools/list":
return {
"tools": [{
"name": "convert_timezone",
"description": "Convert time between timezones",
"inputSchema": {
"type": "object",
"properties": {
"time": {"type": "string", "description": "Time 'YYYY-MM-DD HH:MM'"},
"from_tz": {"type": "string", "description": "Source timezone"},
"to_tz": {"type": "string", "description": "Target timezone"}
},
"required": ["time", "from_tz", "to_tz"]
}
}]
}
elif method == "tools/call":
if params.get("name") != "convert_timezone":
raise Exception(f"Unknown tool: {params.get('name')}")
args = params["arguments"]
try:
result = convert_timezone(args["time"], args["from_tz"], args["to_tz"])
return {"content": [{"type": "text", "text": json.dumps(result, indent=2)}]}
except Exception as e:
raise Exception(f"Tool error: {str(e)}")
else:
raise Exception(f"Unknown method: {method}")
def main():
"""Main server loop"""
while True:
try:
line = sys.stdin.readline()
if not line:
break
request = json.loads(line.strip())
try:
response = handle_request(request)
output = {
"jsonrpc": "2.0",
"id": request.get("id"),
"result": response
}
except Exception as e:
output = {
"jsonrpc": "2.0",
"id": request.get("id"),
"error": {"code": -32000, "message": str(e)}
}
print(json.dumps(output))
sys.stdout.flush()
except json.JSONDecodeError:
error = {
"jsonrpc": "2.0",
"id": None,
"error": {"code": -32700, "message": "Parse error"}
}
print(json.dumps(error))
sys.stdout.flush()
if __name__ == "__main__":
main()Tutorial de inmersión profunda
Para una visión más profunda, Mahesh Murag de Anthropic muestra en el siguiente vídeo una visión detallada de la creación de agentes con el Protocolo de Contexto de Modelo.
Al cargar el vídeo, aceptas la política de privacidad de YouTube.
Más información
Conclusión
El Protocolo de Contexto de Modelos aporta orden y modularidad al mundo de los modelos lingüísticos. En lugar de construir constantemente nuevas interfaces, MCP garantiza un estándar estable. Los servidores MCP no sólo hacen que los LLM sean más inteligentes, sino también más ágiles. Con MCP, los datos, servicios y modelos pueden conectarse de forma limpia, ya sea en la empresa, en el proyecto o para las tareas cotidianas. Esta estandarización y la flexibilidad asociada hacen que las soluciones basadas en LLM puedan escalarse más fácilmente y adaptarse a nuevos requisitos. MCP también fomenta el desarrollo de una animada comunidad en la que desarrolladores y empresas pueden compartir sus propios servidores y herramientas y seguir desarrollándolos juntos. En definitiva, MCP allana el camino hacia un futuro en el que los modelos lingüísticos estén aún más integrados en nuestra vida digital cotidiana y puedan ayudarnos en una amplia gama de tareas.
ES 
DE 
EN 
FR