Amazon Bedrock AgentCoreとNova 2 Sonicを活用したマルチチャネル注文システム

はじめに

Building a voice-enabled ordering system that works across mobile apps, websites, and voice interfaces (an omnichannel approach) presents real challenges. You need to process bidirectional audio streams, maintain conversation context across multiple turns, integrate backend services without tight coupling, and scale to handle peak traffic.

In this post, we’ll show you how to build a complete omnichannel ordering system using Amazon Bedrock AgentCore, an agentic platform, to build, deploy, and operate highly effective AI agents securely at scale using any framework and foundation model and Amazon Nova 2 Sonic. You’ll deploy infrastructure that handles authentication, processes orders, and provides location-based recommendations. The system uses managed services that scale automatically, reducing the operational overhead of building voice AI applications. By the end, you’ll have a working system that processes voice orders across multiple customer touchpoints. The AI orchestration layer connects to a sample backend architecture with sample menu data, giving you a head start while implementing a project of this nature. This project was divided into modules giving you flexibility if you are looking to reuse components for integrating with your existing backend APIs.

In this post, you’ll learn how to:

• Deploy a multi-channel Voice AI ordering infrastructure using AWS Cloud Development Kit (AWS CDK)

• Implement an agent using Strands with Amazon Nova 2 Sonic for real-time speech processing hosted on AgentCore Runtime

• Connect your AI agent to backend services using Model Context Protocol (MCP) through AgentCore Gateway

• Test your system with realistic ordering scenarios including route-based pickup recommendations

Amazon Nova 2 Sonic is a speech-to-speech foundation model available through Amazon Bedrock that you can use for real-time voice interactions. When combined with Amazon Bedrock AgentCore, you get natural voice ordering across all customer touchpoints.

Solution overview

This solution architecture separates your frontend, AI agent, and backend services into distinct components. This separation allows you to develop and scale each component independently. The MCP is an open standard for connecting AI applications to external data sources, tools, and workflows. It provides standardized communication between your agent and backend services.

The solution will deploy:

• Amazon Cognito – Handles user authentication and provides temporary AWS credentials for secure API access. You can change this to your IDP of your choice as long as it is OAuth 2.0 compliant.

• Amazon Bedrock AgentCore Runtime – Hosts your AI agent with microVM isolation. Each user session runs in an isolated virtual machine, which keeps your customer sessions secure and performant even under high load. It prevents one customer’s session from affecting another’s performance or accessing their data.

• Amazon Bedrock AgentCore Gateway – Provides a secure way for developers to build, deploy, discover, and connect to tools at scale, which provides standardized communication between the agent and your business logic without tight coupling, so that you can modify backends or add new tools without rewriting integration code

• Amazon API Gateway – Exposes your backend services through Representational State Transfer (REST) endpoints with AWS Identity and Access Management (IAM) based authorization

• AWS Lambda – Executes your business logic for menu retrieval, order processing, and location services

• Amazon DynamoDB – Stores customer profiles, orders, menu items, and shopping carts with single-digit millisecond latency

• AWS Location Services – Provides location-based features for pickup recommendations

• AWS Amplify – Hosts the frontend application

Architecture diagram

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

Section A: Backend infrastructure

This section deploys a sample restaurant architecture as backend services using infrastructure as code. It provisions data storage for customer information, orders, menus, carts, and locations. It also sets up location-based services for address handling and mapping, Lambda functions for business logic, an API layer for external access, and user authentication and authorization services. Resources are deployed in the appropriate dependency sequence.

Section B: AgentCore Gateway

This section deploys the AgentCore Gateway infrastructure. It provisions the necessary IAM service permissions, creates the AgentCore Gateway service, and configures API integration to expose backend endpoints as agent-accessible tools.

Section C: AgentCore Runtime and ECR image

This section deploys the AgentCore Runtime environment. It provisions Amazon ECR for container storage, Amazon S3 for source uploads, AWS CodeBuild for build automation, and required IAM permissions. The AgentCore Runtime service is configured with WebSocket protocol.

Section D: AWS Amplify

This section deploys the frontend application using AWS Amplify. It provisions the Amplify hosting service with deployment configuration and generates the necessary frontend configuration from backend outputs. The built web application is deployed and becomes accessible via the Amplify URL upon completion.

User request flow:

• The user accesses the web application hosted on AWS Amplify from their browser or mobile device.

• The user authenticates with Amazon Cognito using their username and password and receives JWT tokens (Access Token and ID Token).

• The frontend exchanges the ID Token with the Cognito Identity Pool for temporary AWS credentials (Access Key, Secret Key, Session Token).

• The frontend opens a SigV4-signed WebSocket connection to AgentCore Runtime and sends the Access Token as the first message for identity verification.

• The agent hosted in AgentCore Runtime validates the Access Token by calling the Cognito GetUser API and extracts the customer’s verified name, email, and customerId.

• AgentCore Runtime initializes the Nova 2 Sonic model on Amazon Bedrock and builds a personalized system prompt with the verified customer context.

• AgentCore Runtime connects to AgentCore Gateway as an MCP client using SigV4 authentication and discovers the available tools.

• The user speaks their order. The agent processes the voice input through Nova 2 Sonic and invokes tools asynchronously through the AgentCore Gateway using MCP.

• AgentCore Gateway exposes the backend REST APIs as MCP tools, so that the agent can discover and invoke them by name. When the agent calls a tool, AgentCore Gateway forwards the request as a REST API call to the API Gateway, which routes it to the appropriate Lambda function. Lambda functions query DynamoDB tables and AWS Location Services.

• Nova 2 Sonic generates a contextual voice response incorporating the tool results and streams it back to the user over the WebSocket connection.

Prerequisites

Before you begin, verify you have the following in place:

• An AWS account

• Foundation model (FM) access in Amazon Bedrock for Amazon Nova 2 Sonic in the same AWS Region where you will deploy this solution

• Node.js 20.x or later (required for AWS CDK deployment)

• Python 3.13 or later (required for agent runtime and deployment scripts)

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

• AWS CDK CLI 2.x: npm install -g aws-cdk (required for infrastructure deployment)

• CDK bootstrapped in your target account/region: npx cdk bootstrap

• Boto3 1.38.0 or later (required for bedrock-agentcore-control service support). Install using python3 -m pip install --upgrade boto3 botocore --break-system-packages

• Additional Python packages: python3 -m pip install email-validator pyyaml --break-system-packages

• The accompanying code downloaded from the aws-samples GitHub repo

Deploy solution resources using AWS CDK

Clone the GitHub repository and navigate into the project directory.

git clone https://github.com/aws-samples/sample-omnichannel-ordering-with-amazon-bedrock-agentcore-and-nova-sonic

cd sample-omnichannel-ordering-with-amazon-bedrock-agentcore-and-nova-sonic

Run the deployment script. Both parameters are required. The email address will receive a temporary password for the initial Cognito test user.

./deploy-all.sh --user-email  --user-name ""

The script first runs preflight checks to validate that Node.js, Python, AWS CLI, CDK, credentials, CDK bootstrap, and Bedrock Nova 2 Sonic model access are all in place. If any check fails, it will report what’s missing and offer to auto-install what it can.

After preflight passes, the script runs five steps. Steps 1 through 3 are fully automated. Step 4 (Synthetic Data) will prompt you for a location such as a city, zip code, or address to use as the center point for searching nearby restaurants, a food type to search for (e.g., pizza, burgers, coffee shop, sandwich, tacos), whether to reuse the same address as the customer home, and a confirmation before writing the generated data into DynamoDB. Step 5 (Password Setup) will prompt you to optionally change the temporary Cognito password that was emailed to you. If you choose yes, you will enter the temporary password from the email and set a new permanent password that meets the Cognito policy (8+ characters, uppercase, lowercase, digit, symbol).

After completion, the script outputs the front-end URL (e.g., https://main..amplifyapp.com) that you will use to access the application.

Understanding serverless data management

API Gateway creates a REST API that connects your frontend to backend services with eight IAM-authenticated endpoints and Lambda integration.

Your backend uses five DynamoDB tables supporting the complete ordering workflow. The Customers Table stores profiles (name, email, phone, loyalty tier, points) for personalized recommendations. The Orders Table stores order history with location data and uses a Global Secondary Index to query by location for identifying popular items. The Menu Table stores location-specific items with pricing and availability that varies by restaurant. The Carts Table stores temporary shopping carts with 24-hour TTL for automatic cleanup. The Locations Table stores restaurant data (coordinates, hours, tax rates) for order calculations and recommendations. DynamoDB on-demand capacity scales automatically with traffic.

Understanding location-based services

Location Services provides location-based features that help customers find convenient pickup locations. The system deploys three resources: a Place Index (Esri) for geocoding and address search, a Route Calculator (Esri) for calculating driving routes and detour times, and a Map (VectorEsriNavigation style) for interactive visualization optimized for driving.

Lambda functions provide three capabilities: Nearest Location Search finds the closest restaurants sorted by distance using GPS coordinates and the haversine formula. Route-Based Search identifies restaurants within a specified detour time (default 10 minutes) using actual driving times rather than straight-line distances. Address Geocoding converts street addresses to coordinates when GPS isn’t available.

These features enable context-aware recommendations like “I found a location 2 minutes from your route” or “Your usual location is 5 miles away.”

Understanding voice AI processing with Amazon Bedrock AgentCore

Your AI agent processes voice interactions through Amazon Bedrock AgentCore. Each user session runs in an isolated microVM, which keeps customer sessions secure and performant even under high load. It prevents one customer’s session from affecting another’s performance or accessing their data. AgentCore provides automatic scaling, built-in monitoring, and WebSocket support for real-time voice.

The agent uses the Strands framework to define system prompts, tools, and conversation flow. Nova 2 Sonic provides:

• Speech recognition across accents with background noise tolerance

• Speech response adaptation to user tone and sentiment

• Bidirectional streaming with low latency response times

• Asynchronous tool calling that fetches data in parallel without blocking conversation

• Interruption handling for natural turn-taking

• Context awareness across multiple conversation turns

The voice processing flow: Audio streams from the frontend (16 kHz PCM) via WebSocket to AgentCore Runtime. Nova 2 Sonic transcribes speech, the agent determines intent and selects tools, invokes them asynchronously via MCP, and the AgentCore Gateway translates MCP calls to REST API calls. Lambda functions execute business logic and return results, which the agent incorporates into its response. Nova 2 Sonic generates voice output that streams back to the frontend.

This architecture minimizes latency for conversational ordering.

User authentication

The solution uses Amazon Cognito user pools and identity pools for secure, role-based access control. User pools manage authentication and groups. Identity pools provide temporary AWS credentials linked to IAM roles. Users log in with their username and password to the Cognito User Pool, receiving JSON Web Token (JWT) tokens (Access Token and ID Token). The frontend exchanges the ID Token with the Cognito Identity Pool for temporary AWS credentials (Access Key, Secret Key, Session Token). These credentials sign the WebSocket connection to AgentCore Runtime and API Gateway requests using Signature Version 4 (SigV4). This architecture ensures that only authenticated users can access the application and ordering APIs.

WebSocket connection flow

The following sequence diagram illustrates how the authentication credentials from the previous section establish a direct browser-to-AgentCore connection. Using the temporary AWS credentials, the frontend opens a SigV4-signed WebSocket connection to AgentCore Runtime and sends the Access Token for identity verification. The browser then streams 16kHz PCM audio and receives voice responses, transcriptions, and tool invocation notifications over the same connection. This avoids the need for a server-side proxy.

Voice interaction and dynamic ordering

The following sequence diagram illustrates the flow of a customer’s order query, demonstrating how natural language requests are processed to deliver synchronized responses: