Amazon Bedrock Guardrailsで年齢対応・文脈認識AIを構築

As you deploy generative AI applications to diverse user groups, you might face a significant challenge that impacts user safety and application reliability: verifying each AI response is appropriate, accurate, and safe for the specific user receiving it. Content suitable for adults might be inappropriate or confusing for children, while explanations designed for beginners might be insufficient for domain experts. As AI adoption accelerates across industries, the need to match responses to user age, role, and domain knowledge has become essential for production deployments.

You might attempt to address this through prompt engineering or application-level logic. However, these approaches can create significant challenges. Prompt-based safety controls can be bypassed through manipulation techniques that tricks models into ignoring safety instructions. Application code becomes complex and fragile as personalization requirements grow, and governance becomes inconsistent across different AI applications. Furthermore, the risks of unsafe content, hallucinated information, and inappropriate responses are amplified when AI systems interact with vulnerable users or operate in sensitive domains like education and healthcare. The lack of centralized, enforceable safety policies creates operational inefficiencies and compliance risks.

To address these challenges, we implemented a fully serverless, guardrail-first solution using Amazon Bedrock Guardrails and other AWS services that align with modern AI safety and compliance alignment needs. The architecture provides three main components: dynamic guardrail selection based on user context, centralized policy enforcement through Amazon Bedrock Guardrails, and more secure APIs for authenticated access. You can use this serverless design to deliver personalized, safe AI responses without complex application code more efficiently, securely, and at scale.

In this post, we walk you through how to implement a fully automated, context-aware AI solution using a serverless architecture on AWS. We demonstrate how to design and deploy a scalable system that can:

• Adapt AI responses intelligently based on user age, role, and industry

• Enforce safety policies at inference time that help prevent bypasses by prompt manipulation

• Provide five specialized guardrails for different user segments (children, teens, healthcare professionals, patients, and general adults)

• Enhance operational efficiency with centralized governance and minimal manual intervention

• Scale with user growth and evolving safety requirements

This solution helps organizations looking to deploy responsible AI systems, align with compliance requirements for vulnerable populations, and help maintain appropriate and trustworthy AI responses across diverse user groups without compromising performance or governance.

Solution overview

This solution uses Amazon Bedrock, Amazon Bedrock Guardrails, AWS Lambda, and Amazon API Gateway as core services for intelligent response generation, centralized policy enforcement, and secure access. Supporting components such as Amazon Cognito, Amazon DynamoDB, AWS WAF, and Amazon CloudWatch help enable user authentication, profile management, security, and comprehensive logging.

What makes this approach unique is dynamic guardrail selection, where Amazon Bedrock and Bedrock Guardrails automatically adapt based on authenticated user context (age, role, industry) to help enforce appropriate safety policies at inference time. This guardrail-first approach works alongside prompt-based safety measures to provide layered protection, offering five specialized guardrails: Child Protection (Children’s Online Privacy Protection Act or COPPA-compliant), Teen Educational, Healthcare Professional, Healthcare Patient, and Adult General. These guardrails provide an authoritative policy enforcement layer that governs what the AI model is allowed to say, operating independently of application logic.

The solution uses serverless scalability, enforces safety policies, and adapts responses based on user context—making it well-suited for enterprise AI deployments serving diverse user populations. The solution can be deployed using Terraform, enabling repeatable and end-to-end automation of infrastructure and application components.

As shown in Figure 1, the web UI runs as a local demo server (localhost:8080) for testing and demonstration purposes. For production deployments, organizations can integrate the API endpoints with their existing web applications or deploy the interface to AWS services such as Amazon Simple Storage Service (Amazon S3) with Amazon CloudFront or AWS Amplify.

*Figure 1: Serverless *age-responsive-context-aware-ai-bedrock Architecture* *

Multi-context AI safety strategy

Now that you understand the architecture components, let’s examine how the solution dynamically adapts responses based on different user contexts.The following diagram (Figure 2: age-responsive, context-aware AI with Amazon Bedrock Guardrails workflow) shows how different user profiles are handled:

** * Figure 2: *age-responsive-context-aware-ai-bedrock Workflow* *

How the solution works

The solution workflow includes the following steps (refer to Figure 1: Solution architecture for age-responsive, context-aware AI with Amazon Bedrock Guardrails):

• User request and web interface

Web Interface: User accesses the local demo web interface (runs on localhost:8080 for demonstration purposes)

• User Input: User enters query through a web interface

• User Selection: User selects their profile (Child, Teen, Adult, Healthcare role)

• Request Preparation: Web interface prepares authenticated request with user context

• User authentication

JSON Web Token (JWT) Token Generation: The Amazon Cognito user pool authenticates users and generates JWT tokens

• User Identity: JWT tokens contain user ID and authentication claim

• Token Validation: Secure tokens are passed with the API requests

• AWS WAF security layer

Rate Limiting: AWS WAF applies 2,000 requests per minute limit per IP (adjustable in terraform/variables.tf in Code repository based on your requirements)

• Open Web Application Security Project (OWASP) Protection: Blocks common web threats and malicious requests

• Requests Filtering: Validates request format and blocks suspicious traffic

• API Gateway processing

JWT Authorization: API Gateway validates JWT tokens from Cognito

• Request Routing: Routes authenticated requests to AWS Lambda functions

• Cross-Origin Resource Sharing (CORS): Manages cross-origin requests from the web demo

• Lambda function execution

Input Sanitization: Lambda sanitizes and validates user inputs

• User Context Retrieval: Queries DynamoDB to retrieve user profiles (age, role, industry)

• Context Analysis: Analyzes user demographics to determine the appropriate guardrail

• DynamoDB user profile lookup

Profile Query: Lambda queries the ResponsiveAI-Users table with user_id

• Context Data: Returns age, role, industry, and device information

• Audit Preparation: Prepares audit log entries for the ResponsiveAI-Audit table

• Dynamic guardrail selection

Context Evaluation: AWS Lambda evaluates user age, role, and industry

• Guardrail Mapping: Automatic selection from five specialized Amazon Bedrock Guardrails:

Child (Age

• Safety: Every request must go through a guardrail—no bypass is possible

For a comprehensive overview of each guardrail’s configuration, including content filters, topic restrictions, PII handling, and custom filters, refer to the Guardrail Configuration Details in the Code repository.

• Bedrock AI processing with guardrail protection

Model Invocation: Lambda invokes foundation model in Amazon Bedrock

• Guardrail Application: The selected guardrail filters both input and output

• Content Safety: Custom policies, topic restrictions, and personally identifiable information (PII) detection are applied

• Response Generation: The AI generates context-appropriate, safety-filtered responses

• Response processing and audit logging

Content Approval: Safe responses are delivered with guardrail metadata

• Content Blocking: Inappropriate content triggers context-aware safety messages

• CloudWatch Logging: Interactions are logged for compliance tracking

• DynamoDB Audit: Guardrail interactions are stored in the Responsive AI-Audit table

• Response delivery to user

API Gateway Response: Lambda returns processed responses through Amazon API Gateway

• Direct Response: The system delivers responses directly to users (AWS WAF only filters incoming requests)

• Web Demo Display: Users receive context-appropriate, protected responses

• User Experience: The same query generates different responses based on user context

Example response adaptation

1.** For the question “What is DNA?”, the system generates different responses based on user context:

Student (Age 13):

“DNA is like a recipe book that tells your body how to grow and what you’ll look like! It’s made up of four special letters (A, T, G, C) that create instructions for everything about you.”

Healthcare Professional (Age 35):

“DNA consists of nucleotide sequences encoding genetic information through base pair complementarity. The double helix structure contains coding regions (exons) and regulatory sequences that control gene expression and protein synthesis.”

General Adult (Age 28):

“DNA is a molecule that contains genetic instructions for the development and function of living organisms. It’s structured as a double helix and determines inherited traits.”

2. The following example demonstrates how the same mathematical question receives age-appropriate responses:

Refer to the following screenshots for responses to the question: “How do I solve quadratic equations?” This makes it clearer how the same question gets different responses based on user context.

Teen Student (Age 13): Simple, step-by-step explanation with basic examples and friendly language suitable for middle school level (refer Figure 3)

For Math Teacher (Age 39): Comprehensive pedagogical approach including multiple solution methods, teaching strategies, and advanced mathematical concepts (refer to Figure 4)

** * Figure 3: Teen *Student response with step-by-step guidance* *

• Figure 4: *Educator response with comprehensive teaching approach

Prerequisites

Before deploying the solution, make sure that you have the following installed and configured:

• AWS account

• Required AWS Permissions: Your AWS user or role needs permissions for:

Lambda (create functions)

• Amazon Bedrock (model invocation and guardrail management)

• Cognito (user pools and identity providers)

• AWS WAF (web ACLs and rules)

• DynamoDB (table operations)

• API Gateway (REST API management)

• CloudWatch

• Terraform installed: Required to deploy the solution infrastructure

Implementation

• Clone the GitHub repository:

Open your terminal or command prompt.

• Navigate to the directory where you want to clone the repository.

• Run the following command to clone the repository into the local system.

git clone https://github.com/aws-samples/sample-age-responsive-context-aware-ai-bedrock-guardrails.git

• Deploy infrastructure using Terraform:

Open your terminal or command prompt and navigate to the code repository.

• Use the deploy.sh to deploy the resources and the end-to-end solution.

$ cd sample-age-responsive-context-aware-ai-bedrock-guardrails
$ ./deploy.sh

Testing the solution

The solution includes a web-based demo for immediate testing and advanced API testing capabilities.

For production enterprise deployments, host the web interface using AWS Amplify, Amazon S3 and Amazon CloudFront, or container services like Amazon Elastic Container Service (Amazon ECS) and Amazon Elastic Kubernetes Service (Amazon EKS). For detailed Amazon Bedrock Guardrails testing scenarios, API examples, and validation procedures, refer to the TESTING_GUIDE.md file in the cloned repository.

Interactive web demo**:

• To start the interactive web demo run:

$ cd web-demo
$ ./start_demo.sh

• Open your browser and navigate to http://localhost:8080

• You can use the demo interface to:

Select different user profiles (Child, Teen, Adult, Healthcare roles)

• Submit queries and observe context-aware responses

• View guardrail enforcement in real-time

• Monitor response adaptation based on user context

API testing :

• For programmatic testing, generate a JWT token:

$ cd utils
$ python3 generate_jwt.py student-123

Tes