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.

GitHubPrueba 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 perfecta 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.

— README del Protocolo de Contexto de Modelo

Un servidor MCP es un programa ligero que expone capacidades específicas a través del Protocolo de Contexto de Modelo estandarizado. Las aplicaciones host (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 brindar 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 gestionado 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 con versiones anteriores 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 las 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 capacidades más recientes 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 del dominio: Los servidores MCP proporcionan conocimiento contextual profundo 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.

Explorar por Cómo Estás Trabajando

👨‍💻 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 de 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 fácil 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 instrucciones completas de uso, instalación y desarrollo.

Casos de Uso para 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 usen las últimas APIs 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 implementarlo?" 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 de 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 eficientemente operaciones de datos 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 tu configuración de 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 requisitos específicos y opciones de configuración.

Si tienes problemas con la configuración de MCP o quieres verificar si los parámetros apropiados están en su lugar, puedes intentar 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 último paquete del servidor MCP desde pypi cada vez que inicias tus clientes MCP, pero tiene un costo de mayores tiempos de carga iniciales. Si quieres 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 quieres 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 última versión 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 las "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 incurrir en costos y está sujeto al Precio 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 modelos en 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 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 tus servidores MCP deseados 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 para mostrar que están habilitados. Consulta lo siguiente para ver un 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 el 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 LLMs a través de Bedrock, lo que haría que la facturación pasara por 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, usa 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 Región de AWS 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 mensaje:
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 mensaje 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, buscar contenido usando un navegador web, clonar un repositorio, ejecutar 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 interruptor Act.

Nota: Para obtener los mejores resultados, por favor indícale a Cline que use el AWS MCP Server deseado que quieras utilizar. Por ejemplo, Using the Terraform MCP Server, do...

Comenzando con Cursor

Comenzando con Cursor

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

  2. Puedes colocar la configuración de MCP en dos ubicaciones, dependiendo de 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 quieras 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. Uso de MCP en el Chat El Agente Composer utilizará automáticamente cualquier herramienta MCP que esté listada en Herramientas Disponibles en la página de configuración de MCP si determina que son relevantes. Para provocar el uso intencional de herramientas, por favor indícale a Cursor que use el AWS MCP Server deseado que quieras utilizar. Por ejemplo, Using the Terraform MCP Server, do...

  2. Aprobación de Herramientas Por defecto, cuando el Agente 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 Agente está llamando a la herramienta.

Comenzando con Windsurf

Comenzando con Windsurf

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

  2. Acceder a la Configuración de MCP

    • Navega a Windsurf - Configuración > Configuración Avanzada o usa la Paleta de Comandos > Abrir Página de Configuración de Windsurf
    • 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": []
    },
   }
 }

Ejemplos

Ejemplos listos para usar de AWS MCP Servers en acción están disponibles en el directorio ejemplos. Estos ejemplos 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 este proyecto mejor!

contributors

¡Se aceptan contribuciones de todo tipo! Consulta nuestra guía para contribuyentes para obtener más información.

Guía para desarrolladores

Si quieres agregar un nuevo Servidor MCP 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.

Aviso legal

Antes de usar un Servidor MCP, 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.