AWS MCP Servers

Un conjunto de servidores MCP que brindan a las aplicaciones de IA acceso a la documentación de AWS, orientación contextual y mejores prácticas.

GitHub
1
Prueba este MCPPatrocinado

Documentación

AWS MCP Servers

Un conjunto de servidores MCP especializados que te ayudan a aprovechar al máximo AWS, dondequiera que uses MCP.

GitHub License Codecov OSSF-Scorecard Score

Tabla de Contenidos

¿Qué es el Protocolo de Contexto de Modelo (MCP) y cómo funciona con AWS MCP Servers?

El Protocolo de Contexto de Modelo (MCP) es un protocolo abierto que permite una integración fluida entre aplicaciones de LLM y fuentes de datos y herramientas externas. Ya sea que estés construyendo un IDE impulsado por IA, mejorando una interfaz de chat o creando flujos de trabajo de IA personalizados, MCP proporciona una forma estandarizada de conectar los LLM con el contexto que necesitan.

— Model Context Protocol README

Un Servidor MCP es un programa ligero que expone capacidades específicas a través del Protocolo de Contexto de Modelo estandarizado. Las aplicaciones anfitrionas (como chatbots, IDE y otras herramientas de IA) tienen clientes MCP que mantienen conexiones 1:1 con los servidores MCP. Los clientes MCP comunes incluyen asistentes de codificación de IA agénticos (como Q Developer, Cline, Cursor, Windsurf), así como aplicaciones de chatbot como Claude Desktop, con más clientes próximamente. Los servidores MCP pueden acceder a fuentes de datos locales y servicios remotos para proporcionar contexto adicional que mejore las salidas generadas por los modelos.

AWS MCP Servers utilizan este protocolo para proporcionar a las aplicaciones de IA acceso a la documentación de AWS, orientación contextual y mejores prácticas. A través de la arquitectura estandarizada de cliente-servidor MCP, las capacidades de AWS se convierten en una extensión inteligente de tu entorno de desarrollo o aplicación de IA.

Los servidores MCP de AWS permiten un desarrollo nativo en la nube mejorado, gestión de infraestructura y flujos de trabajo de desarrollo, haciendo que la computación en la nube asistida por IA sea más accesible y eficiente.

El Protocolo de Contexto de Modelo es un proyecto de código abierto dirigido por Anthropic, PBC. y abierto a contribuciones de toda la comunidad. Para obtener más información sobre MCP, puedes encontrar documentación adicional aquí

Eliminación del Soporte para Server Sent Events

Aviso Importante: El 26 de mayo de 2025, se eliminó el soporte para Server Sent Events (SSE) de todos los servidores MCP en sus últimas versiones principales. Este cambio se alinea con las pautas de compatibilidad hacia atrás de la especificación del Protocolo de Contexto de Modelo.

Estamos trabajando activamente para admitir Streamable HTTP, que proporcionará capacidades de transporte mejoradas para versiones futuras.

Para aplicaciones que aún requieran soporte SSE, utiliza la versión principal anterior del servidor MCP correspondiente hasta que puedas migrar a métodos de transporte alternativos.

¿Por qué AWS MCP Servers?

Los servidores MCP mejoran las capacidades de los modelos fundacionales (FM) de varias maneras clave:

  • Mejor Calidad de Salida: Al proporcionar información relevante directamente en el contexto del modelo, los servidores MCP mejoran significativamente las respuestas del modelo para dominios especializados como los servicios de AWS. Este enfoque reduce las alucinaciones, proporciona detalles técnicos más precisos, permite una generación de código más precisa y garantiza que las recomendaciones se alineen con las mejores prácticas actuales de AWS y las capacidades de los servicios.

  • Acceso a la Documentación Más Reciente: Los FM pueden no tener conocimiento de lanzamientos, API o SDK recientes. Los servidores MCP cierran esta brecha al incorporar documentación actualizada, asegurando que tu asistente de IA siempre trabaje con las últimas capacidades de AWS.

  • Automatización de Flujos de Trabajo: Los servidores MCP convierten flujos de trabajo comunes en herramientas que los modelos fundacionales pueden usar directamente. Ya sea CDK, Terraform u otros flujos de trabajo específicos de AWS, estas herramientas permiten a los asistentes de IA realizar tareas complejas con mayor precisión y eficiencia.

  • Conocimiento Especializado de Dominio: Los servidores MCP proporcionan conocimiento profundo y contextual sobre los servicios de AWS que podría no estar completamente representado en los datos de entrenamiento de los modelos fundacionales, lo que permite respuestas más precisas y útiles para tareas de desarrollo en la nube.

Servidores MCP Disponibles

Explora por lo que Estás Construyendo

📚 Acceso en tiempo real a la documentación oficial de AWS

🏗️ Infraestructura y Despliegue

Construye, despliega y gestiona infraestructura en la nube con las mejores prácticas de Infraestructura como Código.

Infraestructura como Código
Plataformas de Contenedores
Serverless y Funciones
Soporte

🤖 IA y Aprendizaje Automático

Mejora las aplicaciones de IA con recuperación de conocimiento, generación de contenido y capacidades de aprendizaje automático.

📊 Datos y Analítica

Trabaja con bases de datos, sistemas de caché y flujos de trabajo de procesamiento de datos.

Bases de Datos SQL y NoSQL
Búsqueda y Analítica
Caché y Rendimiento

🛠️ Herramientas de Desarrollo y Soporte

Acelera el desarrollo con análisis de código, documentación y utilidades de prueba.

📡 Integración y Mensajería

Conecta sistemas con mensajería, flujos de trabajo y servicios de ubicación.

💰 Costos y Operaciones

Monitorea, optimiza y gestiona tu infraestructura y costos de AWS.

Explora según cómo trabajas

👨‍💻 Vibe Coding y Desarrollo

Asistentes de codificación con IA como Amazon Q Developer CLI, Cline, Cursor y Claude Code que te ayudan a construir más rápido

Flujo de trabajo de desarrollo principal
Infraestructura como Código
Desarrollo de Aplicaciones
Desarrollo de Contenedores y Serverless
Pruebas y Datos

💬 Asistentes Conversacionales

Chatbots orientados al cliente, agentes de negocio y sistemas interactivos de preguntas y respuestas

Conocimiento y Búsqueda
Procesamiento y Generación de Contenido
Servicios de Negocio

🤖 Agentes Autónomos en Segundo Plano

Automatización sin interfaz, pipelines ETL y sistemas operativos

Operaciones de Datos y ETL
Caché y Rendimiento
Flujo de Trabajo e Integración
Operaciones y Monitoreo

Módulo de Handler Lambda de MCP para AWS

Una biblioteca de Python para crear handlers HTTP serverless para el Protocolo de Contexto de Modelo (MCP) usando AWS Lambda. Este módulo proporciona un marco flexible para construir endpoints HTTP de MCP con gestión de sesiones conectable, incluido soporte integrado para DynamoDB.

Características:

  • Creación sencilla de handlers HTTP de MCP serverless usando AWS Lambda
  • Sistema de gestión de sesiones conectable
  • Soporte integrado de backend de sesiones DynamoDB
  • Autenticación y autorización personalizables
  • Implementaciones de ejemplo y pruebas

Consulta src/mcp-lambda-handler/README.md para obtener instrucciones completas de uso, instalación y desarrollo.

Casos de Uso de los Servidores

Por ejemplo, puedes usar el AWS Documentation MCP Server para ayudar a tu asistente de IA a investigar y generar código actualizado para cualquier servicio de AWS, como los agentes inline de Amazon Bedrock. Alternativamente, podrías usar el CDK MCP Server o el Terraform MCP Server para que tu asistente de IA cree implementaciones de infraestructura como código que utilicen las APIs más recientes y sigan las mejores prácticas de AWS. Con el Cost Analysis MCP Server, podrías preguntar "¿Cuál sería el costo mensual estimado para este proyecto de CDK antes de desplegarlo?" o "¿Puedes ayudarme a entender los posibles gastos de servicios de AWS para este diseño de infraestructura?" y recibir estimaciones detalladas de costos e información para la planificación presupuestaria. El Valkey MCP Server permite la interacción en lenguaje natural con almacenes de datos Valkey, permitiendo a los asistentes de IA gestionar operaciones de datos de manera eficiente a través de una interfaz conversacional simple.

Instalación y Configuración

Cada servidor tiene instrucciones de instalación específicas. Generalmente, puedes:

  1. Instalar uv desde Astral
  2. Instalar Python usando uv python install 3.10
  3. Configurar credenciales de AWS con acceso a los servicios requeridos
  4. Agregar el servidor a la configuración de tu cliente MCP

Ejemplo de configuración para Amazon Q CLI MCP (~/.aws/amazonq/mcp.json):

{
  "mcpServers": {
    "awslabs.core-mcp-server": {
      "command": "uvx",
      "args": [
        "awslabs.core-mcp-server@latest"
      ],
      "env": {
        "FASTMCP_LOG_LEVEL": "ERROR"
      }
    },
    "awslabs.nova-canvas-mcp-server": {
      "command": "uvx",
      "args": [
        "awslabs.nova-canvas-mcp-server@latest"
      ],
      "env": {
        "AWS_PROFILE": "your-aws-profile",
        "AWS_REGION": "us-east-1",
        "FASTMCP_LOG_LEVEL": "ERROR"
      }
    },
    "awslabs.bedrock-kb-retrieval-mcp-server": {
      "command": "uvx",
      "args": [
        "awslabs.bedrock-kb-retrieval-mcp-server@latest"
      ],
      "env": {
        "AWS_PROFILE": "your-aws-profile",
        "AWS_REGION": "us-east-1",
        "FASTMCP_LOG_LEVEL": "ERROR"
      }
    },
    "awslabs.cost-analysis-mcp-server": {
      "command": "uvx",
      "args": [
        "awslabs.cost-analysis-mcp-server@latest"
      ],
      "env": {
        "AWS_PROFILE": "your-aws-profile",
        "FASTMCP_LOG_LEVEL": "ERROR"
      }
    },
    "awslabs.cdk-mcp-server": {
      "command": "uvx",
      "args": [
        "awslabs.cdk-mcp-server@latest"
      ],
      "env": {
        "FASTMCP_LOG_LEVEL": "ERROR"
      }
    },
    "awslabs.aws-documentation-mcp-server": {
      "command": "uvx",
      "args": [
        "awslabs.aws-documentation-mcp-server@latest"
      ],
      "env": {
        "FASTMCP_LOG_LEVEL": "ERROR"
      },
      "disabled": false,
      "autoApprove": []
    },
    "awslabs.lambda-tool-mcp-server": {
      "command": "uvx",
      "args": [
        "awslabs.lambda-tool-mcp-server@latest"
      ],
      "env": {
        "AWS_PROFILE": "your-aws-profile",
        "AWS_REGION": "us-east-1",
        "FUNCTION_PREFIX": "your-function-prefix",
        "FUNCTION_LIST": "your-first-function, your-second-function",
        "FUNCTION_TAG_KEY": "your-tag-key",
        "FUNCTION_TAG_VALUE": "your-tag-value"
      }
    },
    "awslabs.terraform-mcp-server": {
      "command": "uvx",
      "args": [
        "awslabs.terraform-mcp-server@latest"
      ],
      "env": {
        "FASTMCP_LOG_LEVEL": "ERROR"
      },
      "disabled": false,
      "autoApprove": []
    },
    "awslabs.frontend-mcp-server": {
      "command": "uvx",
      "args": [
        "awslabs.frontend-mcp-server@latest"
      ],
      "env": {
        "FASTMCP_LOG_LEVEL": "ERROR"
      },
      "disabled": false,
      "autoApprove": []
    },
    "awslabs.valkey-mcp-server": {
      "command": "uvx",
      "args": [
        "awslabs.valkey-mcp-server@latest"
      ],
      "env": {
        "VALKEY_HOST": "127.0.0.1",
        "VALKEY_PORT": "6379",
        "FASTMCP_LOG_LEVEL": "ERROR"
      },
      "autoApprove": [],
      "disabled": false
    },
    "awslabs.aws-location-mcp-server": {
      "command": "uvx",
      "args": [
        "awslabs.aws-location-mcp-server@latest"
      ],
      "env": {
        "AWS_PROFILE": "your-aws-profile",
        "AWS_REGION": "us-east-1",
        "FASTMCP_LOG_LEVEL": "ERROR"
      },
      "disabled": false,
      "autoApprove": []
    },
    "awslabs.memcached-mcp-server": {
      "command": "uvx",
      "args": [
        "awslabs.memcached-mcp-server@latest"
      ],
      "env": {
        "MEMCACHED_HOST": "127.0.0.1",
        "MEMCACHED_PORT": "11211",
        "FASTMCP_LOG_LEVEL": "ERROR"
      },
      "autoApprove": [],
      "disabled": false
    },
    "awslabs.git-repo-research-mcp-server": {
      "command": "uvx",
      "args": [
        "awslabs.git-repo-research-mcp-server@latest"
      ],
      "env": {
        "AWS_PROFILE": "your-aws-profile",
        "AWS_REGION": "us-east-1",
        "FASTMCP_LOG_LEVEL": "ERROR",
        "GITHUB_TOKEN": "your-github-token"
      },
      "disabled": false,
      "autoApprove": []
    },
    "awslabs.cloudformation": {
      "command": "uvx",
      "args": [
        "awslabs.cfn-mcp-server@latest"
      ],
      "env": {
        "AWS_PROFILE": "your-aws-profile"
      },
      "disabled": false,
      "autoApprove": []
    }
  }
}

Consulta los README de cada servidor para conocer los requisitos específicos y las opciones de configuración.

Si tienes problemas con la configuración de MCP o deseas verificar si los parámetros adecuados están en su lugar, puedes probar lo siguiente:

# Run MCP server manually with timeout 15s
$ timeout 15s uv tool run <MCP Name> <args> 2>&1 || echo "Command completed or timed out"

# Example (Aurora MySQL MCP Server)
$ timeout 15s uv tool run awslabs.mysql-mcp-server --resource_arn <Your Resource ARN> --secret_arn <Your Secret ARN> ... 2>&1 || echo "Command completed or timed out"

# If the arguments are not set appropriately, you may see the following message:
usage: awslabs.mysql-mcp-server [-h] --resource_arn RESOURCE_ARN --secret_arn SECRET_ARN --database DATABASE
                                --region REGION --readonly READONLY
awslabs.mysql-mcp-server: error: the following arguments are required: --resource_arn, --secret_arn, --database, --region, --readonly

Nota sobre el rendimiento al usar el sufijo uvx "@latest":

Usar el sufijo "@latest" verifica y descarga el paquete más reciente del servidor MCP desde pypi cada vez que inicias tus clientes MCP, pero conlleva un costo de mayores tiempos de carga iniciales. Si deseas minimizar el tiempo de carga inicial, elimina "@latest" y gestiona tu caché de uv tú mismo usando uno de estos enfoques:

  • uv cache clean <tool>: donde {tool} es el servidor MCP que deseas eliminar de la caché e instalar nuevamente (por ejemplo: "awslabs.lambda-tool-mcp-server") (recuerda eliminar los '<>').
  • uvx <tool>@latest: esto actualizará la herramienta con la versión más reciente y la agregará a la caché de uv.

Ejecutar servidores MCP en contenedores

Este ejemplo usa docker con el "awslabs.nova-canvas-mcp-server" y se puede repetir para cada servidor MCP

  • Construye y etiqueta la imagen

    cd src/nova-canvas-mcp-server
docker build -t awslabs/nova-canvas-mcp-server .

  • Opcionalmente, guarda variables de entorno sensibles en un archivo:

    # contents of a .env file with fictitious AWS temporary credentials
AWS_ACCESS_KEY_ID=ASIAIOSFODNN7EXAMPLE
AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
AWS_SESSION_TOKEN=AQoEXAMPLEH4aoAH0gNCAPy...truncated...zrkuWJOgQs8IZZaIv2BXIa2R4Olgk

  • Usa las opciones de docker: --env, --env-file, y --volume según sea necesario porque los "env": {} no están disponibles dentro del contenedor.

    {
  "mcpServers": {
    "awslabs.nova-canvas-mcp-server": {
      "command": "docker",
      "args": [
        "run",
        "--rm",
        "--interactive",
        "--env",
        "FASTMCP_LOG_LEVEL=ERROR",
        "--env",
        "AWS_REGION=us-east-1",
        "--env-file",
        "/full/path/to/.env",
        "--volume",
        "/full/path/to/.aws:/app/.aws",
        "awslabs/nova-canvas-mcp-server:latest"
      ],
      "env": {}
    }
  }
}

Comenzando con Cline y Amazon Bedrock

Comenzando con Cline y Amazon Bedrock

IMPORTANTE: Seguir estas instrucciones puede generar costos y está sujeto a los Precios de Amazon Bedrock. Eres responsable de cualquier costo asociado. Además de seleccionar el modelo deseado en la configuración de Cline, asegúrate de que tu modelo seleccionado (por ejemplo, anthropic.claude-3-7-sonnet) también esté habilitado en Amazon Bedrock. Para más información sobre esto, consulta estos documentos de AWS sobre cómo habilitar el acceso a los Modelos Fundacionales (FMs) de Amazon Bedrock.

  1. Sigue los pasos anteriores en la sección Instalación y Configuración para instalar uv desde Astral, instalar Python y configurar las credenciales de AWS con los servicios requeridos.

  2. Si usas Visual Studio Code, instala la Extensión de Cline para VS Code (o la extensión equivalente para tu IDE preferido). Una vez instalada, haz clic en la extensión para abrirla. Cuando se te solicite, selecciona el nivel que desees. En este caso, usaremos Amazon Bedrock, por lo que el nivel gratuito de Cline es suficiente, ya que enviaremos solicitudes usando la API de Amazon Bedrock en lugar de la API de Cline.

  1. Selecciona el botón MCP Servers.

  1. Selecciona la pestaña Installed, luego haz clic en Configure MCP Servers para abrir el archivo cline_mcp_settings.json.

  1. En el archivo cline_mcp_settings.json, agrega los servidores MCP que desees en el objeto mcpServers. Consulta el siguiente ejemplo que usará algunos de los servidores MCP de AWS actuales disponibles en este repositorio. Asegúrate de guardar el archivo para instalar los servidores MCP.

cline_mcp_settings.json

{
  "mcpServers": {
    "awslabs.core-mcp-server": {
      "command": "uvx",
      "args": ["awslabs.core-mcp-server@latest"],
      "env": {
        "FASTMCP_LOG_LEVEL": "ERROR",
        "MCP_SETTINGS_PATH": "path to your mcp settings file"
      }
    },
    "awslabs.nova-canvas-mcp-server": {
      "command": "uvx",
      "args": ["awslabs.nova-canvas-mcp-server@latest"],
      "env": {
        "AWS_PROFILE": "your-aws-profile",
        "AWS_REGION": "us-east-1",
        "FASTMCP_LOG_LEVEL": "ERROR"
      }
    },
    "awslabs.terraform-mcp-server": {
      "command": "uvx",
      "args": ["awslabs.terraform-mcp-server@latest"],
      "env": {
        "FASTMCP_LOG_LEVEL": "ERROR"
      },
      "disabled": false,
      "autoApprove": []
    },
   }
 }
  1. Una vez instalados, deberías ver una lista de tus servidores MCP en la pestaña MCP Server Installed, y deberían tener un control deslizante verde que indique que están habilitados. Consulta el siguiente ejemplo con dos de los posibles servidores MCP de AWS. Haz clic en Done cuando termines. Ahora deberías ver la interfaz de chat de Cline.

  1. De forma predeterminada, Cline estará configurado como proveedor de API, que tiene límites para el nivel gratuito. A continuación, actualicemos el proveedor de API a AWS Bedrock, para que podamos usar los LLM a través de Bedrock, lo que haría que la facturación se realice a través de tu cuenta de AWS conectada.
  2. Haz clic en el engranaje de configuración para abrir la configuración de Cline. Luego, en API Provider, cambia esto de Cline a AWS Bedrock y selecciona AWS Profile para el tipo de autenticación. Como nota, la opción AWS Credentials también funciona; sin embargo, utiliza credenciales estáticas (Access Key ID y Secret Access Key) en lugar de credenciales temporales que se redistribuyen automáticamente cuando el token expira, por lo que las credenciales temporales con un AWS Profile son el método más seguro y recomendado.

  1. Completa la configuración según el AWS Profile existente que desees usar, selecciona la AWS Region deseada y habilita la inferencia entre regiones.

  1. A continuación, desplázate hacia abajo en la página de configuración hasta llegar al cuadro de texto que dice Custom Instructions. Pega el siguiente fragmento para asegurarte de que el servidor mcp-core se use como punto de partida para cada prompt:
For every new project, always look at your MCP servers and use mcp-core as the starting point every time. Also after a task completion include the list of MCP servers used in the operation.

  1. Una vez que el prompt personalizado esté pegado, haz clic en Done para volver a la interfaz de chat.

  2. Ahora puedes comenzar a hacer preguntas y probar la funcionalidad de tus AWS MCP Servers instalados. La opción predeterminada en la interfaz de chat es Plan, que te proporcionará la salida para que tomes acción manual (por ejemplo, proporcionándote una configuración de muestra que copies y pegues en un archivo). Sin embargo, opcionalmente puedes cambiar esto a Act, lo que permitirá que Cline actúe en tu nombre (por ejemplo, buscando contenido con un navegador web, clonando un repositorio, ejecutando código, etc.). Opcionalmente, puedes activar la sección "Auto-approve" para evitar tener que hacer clic para aprobar las sugerencias; sin embargo, recomendamos dejarla desactivada durante las pruebas, especialmente si tienes seleccionado el toggle de Act.

Nota: Para obtener los mejores resultados, solicita a Cline que use el AWS MCP Server deseado. Por ejemplo, Using the Terraform MCP Server, do...

Primeros pasos con Cursor

Primeros pasos con Cursor

  1. Sigue los pasos anteriores en la sección Instalación y configuración para instalar uv desde Astral, instalar Python y configurar las credenciales de AWS con los servicios requeridos.

  2. Puedes colocar la configuración de MCP en dos ubicaciones, según tu caso de uso:

A. Configuración del proyecto - Para herramientas específicas de un proyecto, crea un archivo .cursor/mcp.json en el directorio de tu proyecto. - Esto te permite definir servidores MCP que solo están disponibles dentro de ese proyecto específico.

B. Configuración global - Para herramientas que deseas usar en todos los proyectos, crea un archivo ~/.cursor/mcp.json en tu directorio de inicio. - Esto hace que los servidores MCP estén disponibles en todos tus espacios de trabajo de Cursor.

.cursor/mcp.json

 {
  "mcpServers": {
    "awslabs.core-mcp-server": {
      "command": "uvx",
      "args": ["awslabs.core-mcp-server@latest"],
      "env": {
        "FASTMCP_LOG_LEVEL": "ERROR"
      }
    },
    "awslabs.nova-canvas-mcp-server": {
      "command": "uvx",
      "args": ["awslabs.nova-canvas-mcp-server@latest"],
      "env": {
        "AWS_PROFILE": "your-aws-profile",
        "AWS_REGION": "us-east-1",
        "FASTMCP_LOG_LEVEL": "ERROR"
      }
    },
    "awslabs.bedrock-kb-retrieval-mcp-server": {
      "command": "uvx",
      "args": ["awslabs.bedrock-kb-retrieval-mcp-server@latest"],
      "env": {
        "AWS_PROFILE": "your-aws-profile",
        "AWS_REGION": "us-east-1",
        "FASTMCP_LOG_LEVEL": "ERROR"
      }
    },
    "awslabs.cost-analysis-mcp-server": {
      "command": "uvx",
      "args": ["awslabs.cost-analysis-mcp-server@latest"],
      "env": {
        "AWS_PROFILE": "your-aws-profile",
        "FASTMCP_LOG_LEVEL": "ERROR"
      }
    },
    "awslabs.cdk-mcp-server": {
      "command": "uvx",
      "args": ["awslabs.cdk-mcp-server@latest"],
      "env": {
        "FASTMCP_LOG_LEVEL": "ERROR"
      }
    },
    "awslabs.aws-documentation-mcp-server": {
      "command": "uvx",
      "args": ["awslabs.aws-documentation-mcp-server@latest"],
      "env": {
        "FASTMCP_LOG_LEVEL": "ERROR"
      },
      "disabled": false,
      "autoApprove": []
    },
    "awslabs.lambda-tool-mcp-server": {
      "command": "uvx",
      "args": ["awslabs.lambda-tool-mcp-server@latest"],
      "env": {
        "AWS_PROFILE": "your-aws-profile",
        "AWS_REGION": "us-east-1",
        "FUNCTION_PREFIX": "your-function-prefix",
        "FUNCTION_LIST": "your-first-function, your-second-function",
        "FUNCTION_TAG_KEY": "your-tag-key",
        "FUNCTION_TAG_VALUE": "your-tag-value"
      }
    },
    "awslabs.terraform-mcp-server": {
       "command": "uvx",
       "args": ["awslabs.terraform-mcp-server@latest"],
       "env": {
         "FASTMCP_LOG_LEVEL": "ERROR"
       },
       "disabled": false,
       "autoApprove": []
     },
    "awslabs.frontend-mcp-server": {
       "command": "uvx",
       "args": ["awslabs.frontend-mcp-server@latest"],
       "env": {
         "FASTMCP_LOG_LEVEL": "ERROR"
       },
       "disabled": false,
       "autoApprove": []
     },
      "awslabs.valkey-mcp-server": {
        "command": "uvx",
        "args": ["awslabs.valkey-mcp-server@latest"],
        "env": {
          "VALKEY_HOST": "127.0.0.1",
          "VALKEY_PORT": "6379",
          "FASTMCP_LOG_LEVEL": "ERROR"
        },
        "autoApprove": [],
        "disabled": false
      },
    "awslabs.aws-location-mcp-server": {
       "command": "uvx",
       "args": ["awslabs.aws-location-mcp-server@latest"],
       "env": {
         "AWS_PROFILE": "your-aws-profile",
         "AWS_REGION": "us-east-1",
         "FASTMCP_LOG_LEVEL": "ERROR"
       },
       "disabled": false,
       "autoApprove": []
    },
    "awslabs.memcached-mcp-server": {
        "command": "uvx",
        "args": ["awslabs.memcached-mcp-server@latest"],
        "env": {
          "MEMCACHED_HOST": "127.0.0.1",
          "MEMCACHED_PORT": "11211",
          "FASTMCP_LOG_LEVEL": "ERROR"
        },
        "autoApprove": [],
        "disabled": false
    },
    "awslabs.git-repo-research-mcp-server": {
      "command": "uvx",
      "args": ["awslabs.git-repo-research-mcp-server@latest"],
      "env": {
        "AWS_PROFILE": "your-aws-profile",
        "AWS_REGION": "us-east-1",
        "FASTMCP_LOG_LEVEL": "ERROR",
        "GITHUB_TOKEN": "your-github-token"
      },
      "disabled": false,
      "autoApprove": []
    },
    "awslabs.cloudformation": {
      "command": "uvx",
      "args": ["awslabs.cfn-mcp-server@latest"],
      "env": {
        "AWS_PROFILE": "your-aws-profile"
      },
      "disabled": false,
      "autoApprove": []
    }
  }
}

  1. Usar MCP en el chat El Composer Agent usará automáticamente cualquier herramienta MCP que esté listada en Available Tools en la página de configuración de MCP si determina que son relevantes. Para provocar el uso intencional de herramientas, solicita a Cursor que use el AWS MCP Server deseado. Por ejemplo, Using the Terraform MCP Server, do...

  2. Aprobación de herramientas De forma predeterminada, cuando el Agent quiere usar una herramienta MCP, mostrará un mensaje pidiendo tu aprobación. Puedes usar la flecha junto al nombre de la herramienta para expandir el mensaje y ver con qué argumentos el Agent está llamando a la herramienta.

Primeros pasos con Windsurf

Primeros pasos con Windsurf

  1. Sigue los pasos anteriores en la sección Instalación y configuración para instalar uv desde Astral, instalar Python y configurar las credenciales de AWS con los servicios requeridos.

  2. Acceder a la configuración de MCP

    • Navega a Windsurf - Settings > Advanced Settings o usa la Command Palette > Open Windsurf Settings Page
    • Busca la sección "Model Context Protocol (MCP) Servers"

  3. Agregar servidores MCP

    • Haz clic en "Add Server" para agregar un nuevo servidor MCP
    • Puedes elegir entre plantillas disponibles como GitHub, Puppeteer, PostgreSQL, etc.
    • Alternativamente, haz clic en "Add custom server" para configurar tu propio servidor

  4. Configuración manual

    • También puedes editar manualmente el archivo de configuración de MCP ubicado en ~/.codeium/windsurf/mcp_config.json

~/.codeium/windsurf/mcp_config.json

{
  "mcpServers": {
    "awslabs.core-mcp-server": {
      "command": "uvx",
      "args": ["awslabs.core-mcp-server@latest"],
      "env": {
        "FASTMCP_LOG_LEVEL": "ERROR",
        "MCP_SETTINGS_PATH": "path to your mcp settings file"
      }
    },
    "awslabs.nova-canvas-mcp-server": {
      "command": "uvx",
      "args": ["awslabs.nova-canvas-mcp-server@latest"],
      "env": {
        "AWS_PROFILE": "your-aws-profile",
        "AWS_REGION": "us-east-1",
        "FASTMCP_LOG_LEVEL": "ERROR"
      }
    },
    "awslabs.terraform-mcp-server": {
      "command": "uvx",
      "args": ["awslabs.terraform-mcp-server@latest"],
      "env": {
        "FASTMCP_LOG_LEVEL": "ERROR"
      },
      "disabled": false,
      "autoApprove": []
    },
   }
 }

Muestras

Ejemplos listos para usar de AWS MCP Servers en acción están disponibles en el directorio samples. Estas muestras proporcionan código funcional y guías paso a paso para ayudarte a comenzar con cada servidor MCP.

Vibe coding

Puedes usar estos servidores MCP con tu asistente de codificación de IA para vibe code. Para consejos y trucos sobre cómo mejorar tu experiencia de vibe coding, consulta nuestra guía.

Recursos adicionales

Seguridad

Consulta CONTRIBUTING para obtener más información.

Contribuciones

¡Un gran agradecimiento a nuestros increíbles contribuyentes! ¡Gracias por hacer de este proyecto algo mejor!

contributors

¡Todo tipo de contribuciones son bienvenidas! Consulta nuestra guía para contribuyentes para obtener más información.

Guía para desarrolladores

Si deseas agregar un nuevo MCP Server a la biblioteca, consulta nuestra guía de desarrollo y asegúrate de seguir nuestras pautas de diseño.

Licencia

Este proyecto está licenciado bajo la Licencia Apache-2.0.

Descargo de responsabilidad

Antes de usar un MCP Server, debes considerar realizar tu propia evaluación independiente para asegurarte de que tu uso cumpla con tus propias prácticas y estándares específicos de seguridad y control de calidad, así como con las leyes, reglas y regulaciones que te rigen a ti y a tu contenido.