Skip to main content
skill CX Codex

aws-cloudformation-bedrock — Claude Code skill: overview

aws-cloudformation-bedrock provides AWS CloudFormation patterns for Amazon Bedrock resources. Generates infrastructure for Bedrock agents, knowledge bases, S3 data sources, and guardrails.

MIT ★ 372 updated 2026-09-10

Install into Claude Code · Plugin marketplace All methods and platforms ↓
/plugin marketplace add giuseppe-trisciuoglio/developer-kit
/plugin install developer-kit-aws@developer-kit
Open on GitHub

What aws-cloudformation-bedrock does

This skill guides Claude Code through generating production-ready CloudFormation templates for Amazon Bedrock. It includes resource configurations for AWS::Bedrock::Agent, AWS::Bedrock::KnowledgeBase, S3 data sources, content moderation guardrails, and action groups backed by AWS Lambda running Python 3.12.

A functioning deployment strictly requires configured AWS::IAM::Role resources with trust policies for bedrock.amazonaws.com. Without these policies, stack deployment fails. The skill supplies policies for both agent execution and S3 knowledge base access.

Templates include parameter blocks for foundation models such as anthropic.claude-3-sonnet-20240229-v1:0 and Titan embeddings. The skill also provides CLI commands for template validation and post-deploy checks.

What it helps with

  • Generate CloudFormation templates for Bedrock agents and action groups
  • Set up RAG knowledge bases with S3 data connectors and vector storage
  • Configure Bedrock guardrails for profanity and misconduct content filtering
  • Define IAM roles with permissions for model invocation and data retrieval

Example prompts for the agent

  • Generate a CloudFormation template for a Bedrock agent using Claude 3 Sonnet and S3
  • Write a CloudFormation snippet for a Bedrock knowledge base with Titan embeddings
  • Add an AWS::Bedrock::Guardrail resource with filters for profanity and misconduct

How to install aws-cloudformation-bedrock

1Plugin marketplace

/plugin marketplace add giuseppe-trisciuoglio/developer-kit
/plugin install developer-kit-aws@developer-kit

This installs the whole developer-kit-aws plugin with all its skills

2Skills CLI (Vercel)

npx skills add giuseppe-trisciuoglio/developer-kit --skill aws-cloudformation-bedrock -a claude-code

3Manually: put the files in place

~/.claude/skills/aws-cloudformation-bedrock/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/aws-cloudformation-bedrock/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about aws-cloudformation-bedrock

How do I install aws-cloudformation-bedrock in Claude Code?

Add the marketplace and install the AWS plugin by running /plugin marketplace add giuseppe-trisciuoglio/developer-kit followed by /plugin install developer-kit-aws@developer-kit.

What does aws-cloudformation-bedrock do?

It adds CloudFormation templates and verification steps for Amazon Bedrock resources, including agents, knowledge bases, and content moderation guardrails.

How do you validate Bedrock templates before deployment?

Run aws cloudformation validate-template --template-body file://bedrock-template.yaml in your terminal to inspect syntax before creating the stack.

Source text

SKILL.md · MIT
---
name: aws-cloudformation-bedrock
description: Provides AWS CloudFormation patterns for Amazon Bedrock resources including agents, knowledge bases, data sources, guardrails, prompts, flows, and inference profiles. Use when creating Bedrock agents with action groups, implementing RAG with knowledge bases, configuring vector stores, setting up content moderation guardrails, managing prompts, orchestrating workflows with flows, and configuring inference profiles for model optimization.
allowed-tools: Read, Write, Bash
---

# AWS CloudFormation Amazon Bedrock

## Overview

Creates production-ready AI infrastructure using AWS CloudFormation templates for Amazon Bedrock. Covers Bedrock agents, knowledge bases for RAG implementations, data source connectors, guardrails for content moderation, prompt management, workflow orchestration with flows, and inference profiles for optimized model access.

## When to Use

- Creating Bedrock agents with action groups
- Implementing RAG with knowledge bases
- Configuring S3 or web crawl data sources
- Setting up content moderation guardrails
- Managing prompt templates
- Orchestrating AI workflows with Bedrock Flows
- Configuring inference profiles for multi-model access
- Organizing templates with Parameters and cross-stack references

## Instructions

### 1. Define Parameters

```yaml
Parameters:
  FoundationModel:
    Type: String
    Default: anthropic.claude-3-sonnet-20240229-v1:0
    AllowedValues:
      - anthropic.claude-3-sonnet-20240229-v1:0
      - anthropic.claude-3-haiku-20240307-v1:0
      - amazon.titan-text-express-v1
    Description: Foundation model for agent
```

### 2. Create Agent Role

```yaml
Resources:
  AgentRole:
    Type: AWS::IAM::Role
    Properties:
      AssumeRolePolicyDocument:
        Version: "2012-10-17"
        Statement:
          - Effect: Allow
            Principal:
              Service: bedrock.amazonaws.com
            Action: sts:AssumeRole
      Policies:
        - PolicyName: BedrockPermissions
          PolicyDocument:
            Version: "2012-10-17"
            Statement:
              - Effect: Allow
                Action:
                  - bedrock:InvokeModel
                Resource: !Sub "arn:aws:bedrock:${AWS::Region}:${AWS::AccountId}:foundation-model/${FoundationModel}"
```

### 3. Create Agent

```yaml
  BedrockAgent:
    Type: AWS::Bedrock::Agent
    Properties:
      AgentName: !Sub "${AWS::StackName}-agent"
      AgentResourceRoleArn: !GetAtt AgentRole.Arn
      FoundationModelArn: !Sub "arn:aws:bedrock:${AWS::Region}::foundation-model/${FoundationModel}"
      AutoPrepare: true
      Instruction: |
        You are a helpful assistant. Use the knowledge base to answer questions.
```

### 4. Create Knowledge Base

```yaml
  KnowledgeBaseRole:
    Type: AWS::IAM::Role
    Properties:
      AssumeRolePolicyDocument:
        Version: "2012-10-17"
        Statement:
          - Effect: Allow
            Principal:
              Service: bedrock.amazonaws.com
            Action: sts:AssumeRole

  KnowledgeBase:
    Type: AWS::Bedrock::KnowledgeBase
    Properties:
      Name: !Sub "${AWS::StackName}-kb"
      RoleArn: !GetAtt KnowledgeBaseRole.Arn
      KnowledgeBaseConfiguration:
        Type: VECTOR
        VectorKnowledgeBaseConfiguration:
          EmbeddingModelArn: !Sub "arn:aws:bedrock:${AWS::Region}::embedding-model/amazon.titan-embed-text-v1"
```

### 5. Create Data Source

```yaml
  DataBucket:
    Type: AWS::S3::Bucket

  S3DataSource:
    Type: AWS::Bedrock::DataSource
    Properties:
      KnowledgeBaseId: !Ref KnowledgeBase
      Name: s3-data-source
      Type: S3
      DataSourceConfiguration:
        S3Configuration:
          BucketArn: !GetAtt DataBucket.Arn
          InclusionPrefixes:
            - documents/
```

### 6. Add Guardrail

```yaml
  Guardrail:
    Type: AWS::Bedrock::Guardrail
    Properties:
      Name: !Sub "${AWS::StackName}-guardrail"
      BlockedInputMessaging: "I cannot help with that request."
      ContentPolicyConfig:
        filtersConfig:
          - type: PROFANITY
          - type: MISCONDUCT
```

### 7. Create Action Group

```yaml
  ActionLambdaFunction:
    Type: AWS::Lambda::Function
    Properties:
      Runtime: python3.12
      Handler: index.handler
      Role: !GetAtt ActionLambdaRole.Arn
      Code:
        ZipFile: |
          def handler(event, context):
              return {"statusCode": 200, "body": "{\"result\": \"success\"}"}

  ActionGroup:
    Type: AWS::Bedrock::AgentActionGroup
    Properties:
      ActionGroupName: api-operations
      ActionGroupState: ENABLED
      AgentId: !GetAtt BedrockAgent.AgentId
      ActionGroupExecutor:
        Lambda: !Ref ActionLambdaFunction
      FunctionSchema:
        functionConfigurations:
          - function: |
              { "name": "get_inventory", "description": "Get current inventory status", "parameters": { "type": "object", "properties": { "sku": { "type": "string" } }, "required": [] } }
```

### 8. Validate Before Deploy

Always validate the template before deployment:

```bash
aws cloudformation validate-template --template-body file://bedrock-template.yaml
```

### 9. Verify After Deploy

```bash
# Check agent status
aws bedrock-agent get-agent --agent-id $(aws cloudformation describe-stacks --stack-name STACK_NAME --query 'Stacks[0].Outputs[?OutputKey==`AgentId`].OutputValue' --output text)

# Check knowledge base sync status
aws bedrock-agent list-knowledge-bases --agent-id AGENT_ID

# Test guardrail
aws bedrock-runtime apply_guardrail --guardrail-identifier GUARDRAIL_ID --source SOURCE
```

## Examples

### Minimal RAG Agent Template

Complete working template for a RAG-enabled agent:

```yaml
AWSTemplateFormatVersion: "2010-09-09"
Description: "Bedrock RAG Agent with Knowledge Base"

Parameters:
  FoundationModel:
    Type: String
    Default: anthropic.claude-3-sonnet-20240229-v1:0

Resources:
  # IAM Role for Agent
  AgentRole:
    Type: AWS::IAM::Role
    Properties:
      RoleName: !Sub "${AWS::StackName}-agent-role"
      AssumeRolePolicyDocument:
        Version: "2012-10-17"
        Statement:
          - Effect: Allow
            Principal:
              Service: bedrock.amazonaws.com
            Action: sts:AssumeRole
      Policies:
        - PolicyName: InvokeModel
          PolicyDocument:
            Version: "2012-10-17"
            Statement:
              - Effect: Allow
                Action: bedrock:InvokeModel
                Resource: "*"

  # IAM Role for Knowledge Base
  KnowledgeBaseRole:
    Type: AWS::IAM::Role
    Properties:
      RoleName: !Sub "${AWS::StackName}-kb-role"
      AssumeRolePolicyDocument:
        Version: "2012-10-17"
        Statement:
          - Effect: Allow
            Principal:
              Service: bedrock.amazonaws.com
            Action: sts:AssumeRole
      Policies:
        - PolicyName: S3Access
          PolicyDocument:
            Version: "2012-10-17"
            Statement:
              - Effect: Allow
                Action: s3:GetObject
                Resource: !Sub "${DataBucket.Arn}/*"

  # S3 Bucket for Documents
  DataBucket:
    Type: AWS::S3::Bucket

  # Knowledge Base
  KnowledgeBase:
    Type: AWS::Bedrock::KnowledgeBase
    Properties:
      Name: !Sub "${AWS::StackName}-kb"
      RoleArn: !GetAtt KnowledgeBaseRole.Arn
      KnowledgeBaseConfiguration:
        Type: VECTOR
        VectorKnowledgeBaseConfiguration:
          EmbeddingModelArn: !Sub "arn:aws:bedrock:${AWS::Region}::embedding-model/amazon.titan-embed-text-v1"

  # Data Source
  DataSource:
    Type: AWS::Bedrock::DataSource
    Properties:
      KnowledgeBaseId: !Ref KnowledgeBase
      Name: !Sub "${AWS::StackName}-ds"
      Type: S3
      DataSourceConfiguration:
        S3Configuration:
          BucketArn: !GetAtt DataBucket.Arn

  # Bedrock Agent
  BedrockAgent:
    Type: AWS::Bedrock::Agent
    Properties:
      AgentName: !Sub "${AWS::StackName}-agent"
      AgentResourceRoleArn: !GetAtt AgentRole.Arn
      FoundationModelArn: !Sub "arn:aws:bedrock:${AWS::Region}::foundation-model/${FoundationModel}"
      AutoPrepare: true
      Instruction: |
        You are a helpful assistant. Use the knowledge base to answer user questions accurately.

Outputs:
  AgentId:
    Description: Bedrock Agent ID
    Value: !GetAtt BedrockAgent.AgentId
  KnowledgeBaseId:
    Description: Knowledge Base ID
    Value: !Ref KnowledgeBase
```

### Guardrail with Content Filtering

```yaml
Resources:
  Guardrail:
    Type: AWS::Bedrock::Guardrail
    Properties:
      Name: !Sub "${AWS::StackName}-guardrail"
      blockedInputMessaging: "Content blocked by safety filters."
      blockedOutputMessaging: "Response filtered for safety."
      contentPolicyConfig:
        filtersConfig:
          - type: PROFANITY
            inputStrength: HIGH
            outputStrength: HIGH
          - type: MISCONDUCT
            inputStrength: HIGH
            outputStrength: HIGH
      sensitiveInformationPolicyConfig:
        piiEntitiesConfig:
          - type: EMAIL
            action: ANONYMIZE
          - type: SSN
            action: BLOCK
```

## Best Practices

### Security
- Use least privilege IAM policies for agent and knowledge base roles
- Restrict web crawl data sources to trusted internal domains
- Encrypt sensitive data in knowledge bases
- Parameterize all TemplateURL values for nested stacks

### Cost Optimization
- Select appropriate model size for task complexity
- Configure retrieval filtering to reduce token usage
- Set chunk size limits to control storage costs
- Monitor usage with CloudWatch dashboards

### Performance
- Optimize chunk size for embedding quality
- Use provisioned throughput for high-traffic vector stores
- Configure appropriate knowledge base sync intervals
- Implement caching for frequently accessed content

### Validation
- Always run `aws cloudformation validate-template` before deploy
- Verify agent status after stack creation completes
- Test guardrails with sample inputs
- Monitor knowledge base sync status in CloudWatch

## Constraints and Warnings

For detailed limits, see [constraints.md](references/constraints.md):

- **Regional limits**: Not all models available in all regions
- **Agent initialization**: AutoPrepare may take several minutes
- **Knowledge base sync**: S3 sync is near-instant; web crawl takes longer
- **Web crawl security**: Always restrict to trusted domains to prevent prompt injection
- **Token limits**: Configure MaxTokens parameter for your use case
- **Quota management**: Request quota increases via AWS Support if needed

### Security

- Restrict web crawl data sources to trusted internal domains only
- Validate content before ingesting into knowledge bases
- Use parameterized TemplateURL values for nested stacks
- Implement guardrails for content moderation
- Apply least privilege IAM policies to agent roles
- Encrypt sensitive data in knowledge bases
- Monitor for prompt injection in web-crawled content

### Cost Optimization

- Use appropriate model selection for task complexity
- Implement knowledge base retrieval filtering
- Set chunk size limits to control token usage
- Monitor token consumption with CloudWatch
- Use auto-prepare agents strategically
- Implement batch processing for non-real-time workloads
- Use knowledge base filtering to reduce costs

### Performance

- Optimize chunk size for embedding quality vs. cost
- Use vector store optimization (OpenSearch, Pinecone)
- Implement caching for frequently accessed knowledge base content
- Configure appropriate knowledge base sync intervals
- Use provisioned throughput for vector databases
- Monitor agent initialization and cold start times
- Implement graceful degradation for rate limiting

### Data Management

- Use appropriate inclusion/exclusion filters for data sources
- Implement document validation before indexing
- Use versioning for knowledge base updates
- Configure appropriate sync intervals for data sources
- Implement content deduplication in knowledge bases
- Use metadata filtering for improved retrieval accuracy
- Monitor knowledge base size and document limits

## References

- **[constraints.md](references/constraints.md)** - Resource limits, regional constraints, operational limits, and cost considerations
- **[reference.md](references/reference.md)** - API reference and resource properties
- **[examples.md](references/examples.md)** - Additional usage examples

## Related Resources

- [Amazon Bedrock Documentation](https://docs.aws.amazon.com/bedrock/)
- [CloudFormation Bedrock Resource Types](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-bedrock-agent.html)
- [Bedrock Agents User Guide](https://docs.aws.amazon.com/bedrock/latest/userguide/agents.html)
- [Bedrock Knowledge Bases](https://docs.aws.amazon.com/bedrock/latest/userguide/knowledge-base.html)
- [Bedrock Guardrails](https://docs.aws.amazon.com/bedrock/latest/userguide/guardrails.html)

© Giuseppe Trisciuoglio · MIT · giuseppe-trisciuoglio/developer-kit

Similar skills

All skills for Cloud: AWS, Azure, GCP →

From the same set191

The whole set →
wordpress-sage-theme wordpress-sage-theme walks Claude through building a WordPress theme on Sage: Blade views, Bud or Vite builds, ACF fields. PHP 8.0+, Node.js 18+ and Composer are needed first. CX Codex +1 ★ 372repo stars php-code-review-expert php-code-review-expert reviews PHP 8.3+, Laravel, and Symfony changes for security flaws, ORM issues, and type errors while discarding low-confidence noise. CX Codex ★ 372repo stars aws-cost-optimization The aws-cost-optimization skill reviews AWS spending across five cost areas and suggests concrete checks for EC2, EBS, S3, budgets, and pricing choices. CX Codex +1 ★ 372repo stars typescript-security-expert typescript-security-expert is a Claude Code subagent that audits TypeScript and Node.js application security. It handles vulnerability reviews, threat modeling, and DevSecOps work. CX Codex ★ 372repo stars python-software-architect-expert python-software-architect-expert reviews Python project structure through Clean Architecture, DDD, and SOLID principles. Use it to examine module boundaries or get guidance on architecture decisions. CX Codex ★ 372repo stars aws-architecture-review-expert aws-architecture-review-expert audits CloudFormation templates and AWS architecture against Well-Architected Framework pillars, security standards, and cost risks. CX Codex ★ 372repo stars devkit.generate-document The devkit.generate-document command examines a codebase and drafts structured technical or business documents. Choose a document type, language, and objective. CX Codex +1 ★ 372repo stars speckit.check-integration speckit.check-integration reads tasks.md and flags tasks that overlap with code you already have, so you can reuse it instead of writing a second version. CX Codex +1 ★ 372repo stars

Project sponsors

Companies that keep this analytics open