Amazon Bedrock AgentCoreとSlackの統合

Integrating Amazon Bedrock AgentCore with Slack brings AI agents directly into your workspace. Your teams can interact with agents without jumping between applications, losing conversation history, or re-authenticating. The integration handles three technical requirements: validating Slack event requests for security, maintaining conversation context across threads, and managing responses that exceed Slack’s timeout limits.

Developers typically spend time building custom webhook handlers for Slack integrations. AgentCore helps remove this work by providing built-in conversation memory, secure access to agents and their tools, and identity management that tracks agent usage, all from within Slack.

In this post, we demonstrate how to build a Slack integration using AWS Cloud Development Kit (AWS CDK). You will learn how to deploy the infrastructure with three specialized AWS Lambda functions, configure event subscriptions properly to handle Slack’s security requirements, and implement conversation management patterns that work for many agent use cases. We’re using a weather agent as our example, but the integration layer that you’re building is completely reusable. You can customize the runtime and tools for your specific business needs without changing how Slack communicates with your agent.

Solution overview

This solution consists of two main components: The Slack integration infrastructure and the Amazon AgentCore Runtime with tools. The integration infrastructure routes and manages communication between Slack and the agent, as the runtime processes and responds to queries.

The integration infrastructure in this solution uses Amazon API Gateway, AWS Lambda, AWS Secrets Manager, and Amazon Simple Queue Service (Amazon SQS) for serverless integration.

The agent has been containerized and hosted to run in AgentCore Runtime. It’s built with the Strands Agents SDK that integrates with Amazon Bedrock AgentCore Gateway for tool access and AgentCore Memory for conversation history. The runtime maintains context throughout conversations and uses the Model Context Protocol (MCP), a standardized protocol for tool execution and communication, to invoke tools.

With these components in place, the following section examines how they work together in the architecture.

Architecture diagram

The following diagram represents the solution architecture, which contains three key sections:

Section A – Image Build Infrastructure – First, WeatherAgentImageStack CDK deploys the container image build pipeline (Amazon Simple Storage Service (Amazon S3) bucket, AWS CodeBuild project, and Amazon Elastic Container Registry (Amazon ECR) repository). This uses CodeBuild to create AWS Graviton (ARM64) container images that are stored in the ECR repository for use by the AgentCore Runtime.

Section B – AgentCore Components – Next, WeatherAgentCoreStack CDK deploys the AgentCore Runtime, Gateway, Memory, and AWS Lambda function. The Runtime uses the Strands Agents Framework an Open Source AI Agents SDK to orchestrate model invocations, tool calls, and conversation memory.

Section C – Slack Integration Infrastructure – Lastly, WeatherAgentSlackStack deploys the integration infrastructure (API Gateway, Secrets Manager, Lambda functions, and SQS). This handles webhook verification, Amazon Simple Queue Service (Amazon SQS) queuing, and message processing through three Lambda functions. This layer is reusable for AgentCore use cases.

The request flow consists of the following steps:

• A user sends a message in Slack through direct message or @appname in a channel.

• Slack sends a webhook POST request to API Gateway.

• The request is forwarded to the verification Lambda function.

• The Lambda retrieves the Slack signing secret and bot token from Secrets Manager to verify authenticity.

• After verification, the Lambda asynchronously invokes the SQS integration Lambda.

• The SQS integration Lambda sends a “Processing your request…” message to the user in a Slack thread.

• The SQS integration Lambda sends the message to the SQS FIFO queue.

• The queue triggers the Agent Integration Lambda.

• The Lambda invokes AgentCore Runtime with the user’s query and a session ID from the Slack thread timestamp.

• AgentCoreMemorySessionManager retrieves conversation history from AgentCore Memory using the session ID (thread timestamp) and actor ID (user ID).

• The Strands Framework retrieves tools from AgentCore Gateway using the MCP protocol.

• The Strands Framework invokes the Amazon Bedrock model (Nova Pro) with the message, context, and tools.

• The model determines which tools to invoke and generates requests.

• The Gateway routes tool invocations to the MCP server on Lambda, which executes weather tools.

• Tool results return to the Strands Framework, which can invoke the model again if needed.

• The Strands Framework stores the conversation turn in AgentCore Memory.

• The Agent Integration Lambda updates the “Processing your request…” message with the agent’s response.

Prerequisites

This solution requires the following prerequisites:

• AWS account with permissions for:

Amazon Bedrock AgentCore, Lambda, API Gateway, SQS, ECR, CodeBuild, AWS Identity and Access Management (IAM), Secrets Manager, Amazon Bedrock

• AWS Command Line Interface (AWS CLI) (v2.x) configured with credentials

• Node.js (v18 or later) and npm installed

• AWS CDK installed and bootstrapped in your AWS account

Install: npm install -g aws-cdk

• Bootstrap: cdk bootstrap aws://ACCOUNT-NUMBER/REGION

• Slack account (two options):

For company Slack accounts, work with your administrator to create and publish the integration application, or you can use a sandbox organization

• Alternatively, create your own Slack account and workspace for testing and experimentation

Step 1: Create a Slack App

Creating applications in Slack requires specific permissions that vary by organization. If the necessary access is unavailable, contact your Slack administrator. The screenshots in this walkthrough are from a personal Slack account and are intended to demonstrate the implementation process that can be followed for this solution.

• Go to Slack API and choose Create New App.

• In the Create an app pop-up, choose From scratch.

• For App Name, enter agent-core-weather-agent.

• For Pick a workspace to develop your app in, choose the workspace where you want to use this application.

• Choose Create App.

After the application is created, you will be taken to the Basic Information page.

• In the navigation pane under Features, choose OAuth & Permissions.

• Navigate to the Scopes section and under Bot Token Scopes, add the following scopes by choosing Add an OAuth Scope and entering:

app_mentions:read

• chat:write

• im:history

• im:read

• im:write

• On the OAuth & Permissions page, navigate to the OAuth Tokens section and choose Install to ExampleCorp.

• On the following page, choose Allow to complete the process.

• On the OAuth & Permissions page, navigate to OAuth Tokens and copy the value for the Bot User OAuth Token that has been created. Save this in a notepad to use later when you’re deploying the infrastructure.

• In the navigation pane under Settings, choose Basic Information.

• Navigate to Signing Secret and choose

• Copy and save this value to your notepad to use later when you’re deploying the infrastructure.

• To allow direct messaging with the app within Slack, navigate to App Home in the navigation pane under

• In the Show Tabs section, enable Allow users to send Slash commands and messages from the messages tab.

Note: You will complete the Event Subscriptions configuration in Step 3 after deploying the infrastructure and obtaining the Webhook URL.

Step 2: Deploy the infrastructure

Clone the GitHub repository and navigate to the project directory:

git clone https://github.com/aws-samples/sample-Integrating-Amazon-Bedrock-AgentCore-with-Slack

cd sample-Integrating-Amazon-Bedrock-AgentCore-with-Slack

The deployment requires setting Slack credentials as environment variables and running the deployment script.

export SLACK_BOT_TOKEN="xoxb-your-token-here"
export SLACK_SIGNING_SECRET="your-signing-secret-here"
./deploy.sh

The deployment takes approximately 10–15 minutes and creates three CDK stacks: an Image Stack for the container build, an Agent Stack with Runtime, Gateway, and Memory, and a Slack Stack with API Gateway and Lambda functions. The deployment output provides the Webhook URL for the next step.

Step 3: Configure Slack event subscriptions

After deploying the infrastructure and obtaining the Webhook URL, the Slack app configuration can be completed.

• The configuration requires returning to the Slack app at Slack API and selecting the agent-core-weather-agent

• In the navigation pane under Features, choose Event Subscriptions.

• Toggle Enable Events to

• In the Request URL field, paste the Webhook URL from the deployment output.

• After the URL is verified (indicated by a green checkmark with ‘Verified’), navigate to the Subscribe to bot events

• Choose Add Bot User Event and add the following events:

app_mention

• im

• Choose Save Changes at the bottom of the page.

• Under Settings, navigate to Install App and select Reinstall to ExampleCorp. When the pop-up screen appears, select Allow.

Step 4: Test the integration of AgentCore in Slack

Testing requires locating agent-core-weather-agent in the Apps section of Slack. You can invite the APP to an existing channel by typing in /invite @agent-core-weather-agent. After adding this application to a channel, users can interact with the AgentCore Agent by using @agent-core-weather-agent to get weather information, or you can also chat directl