AWS Bedrock: Getting Started with Generative AI on AWS

The rest of this guide explains what you're paying for and how to build on it.

What Is AWS Bedrock?

Amazon Bedrock is a serverless service that provides:

• Foundation model access - Claude, Llama, Mistral, and more via API
• Fine-tuning capabilities - Customize models with your data
• RAG support - Connect models to your knowledge bases
• Agents - Build autonomous AI workflows
• Guardrails - Control model outputs for safety

Think of Bedrock as a "model marketplace with infrastructure"—you choose which AI models to use, AWS handles scaling, security, and availability.

Why Use Bedrock Instead of Direct APIs?

You could use Anthropic's API directly, so why go through AWS?

Factor	Direct API	AWS Bedrock
Billing	Separate vendor	Consolidated AWS billing
Data residency	Varies by provider	Stays in your AWS region
VPC integration	Requires configuration	PrivateLink available
IAM integration	API keys only	Native IAM policies
Multiple models	Multiple accounts/APIs	Single API, many models
Compliance	Varies	AWS compliance (HIPAA, SOC2, etc.)
Model switching	Code changes	Configuration changes

Key benefit: If you're already on AWS and need enterprise controls (VPC, IAM, compliance), Bedrock simplifies integration significantly.

Available Foundation Models

Bedrock offers models from multiple providers:

Text Generation Models

Provider	Model	Context Window	Best For
Anthropic	Claude 3.5 Sonnet	200K tokens	Complex reasoning, coding
Anthropic	Claude 3 Haiku	200K tokens	Fast, cost-effective tasks
Meta	Llama 3.1 70B	128K tokens	Open-weight alternative
Mistral	Mistral Large	128K tokens	Multilingual, coding
Amazon	Titan Text	8K tokens	Basic text tasks
Cohere	Command R+	128K tokens	RAG applications

Image Generation Models

Provider	Model	Use Case
Stability AI	SDXL 1.0	High-quality image generation
Amazon	Titan Image Generator	Text-to-image, editing

Embedding Models

Provider	Model	Dimensions
Amazon	Titan Embeddings V2	1024
Cohere	Embed	1024

Bedrock Pricing Explained

Bedrock uses token-based pricing—you pay per input and output token processed. Pricing varies significantly by model.

Text Model Pricing (per 1,000 tokens)

Model	Input Price	Output Price
Claude 3.5 Sonnet	$0.003	$0.015
Claude 3 Haiku	$0.00025	$0.00125
Llama 3.1 70B	$0.00099	$0.00099
Mistral Large	$0.004	$0.012
Titan Text Express	$0.0002	$0.0006

Example Cost Calculation

Processing a customer support request (500 input tokens, 200 output tokens) with Claude 3.5 Sonnet:

Input: 500 / 1000 × $0.003 = $0.0015
Output: 200 / 1000 × $0.015 = $0.003
Total per request: $0.0045

1,000 requests/day = $4.50/day = ~$135/month

Provisioned Throughput

For predictable, high-volume workloads, Bedrock offers Provisioned Throughput:

• Commit to model units for 1 or 6 months
• Get guaranteed capacity
• Potentially lower per-token costs at scale
• Prices vary by model and commitment term

Getting Started: Your First Bedrock Call

Prerequisites

1. AWS account with Bedrock access enabled
2. Request model access in the Bedrock console (some models require approval)
3. IAM permissions for bedrock:InvokeModel

Python Example with Boto3

import boto3
import json

# Create Bedrock runtime client
bedrock = boto3.client(
    service_name='bedrock-runtime',
    region_name='us-east-1'
)

# Prepare the request for Claude
body = json.dumps({
    "anthropic_version": "bedrock-2023-05-31",
    "max_tokens": 1024,
    "messages": [
        {
            "role": "user",
            "content": "Explain what AWS Bedrock is in 2 sentences."
        }
    ]
})

# Invoke the model
response = bedrock.invoke_model(
    modelId="anthropic.claude-3-sonnet-20240229-v1:0",
    contentType="application/json",
    accept="application/json",
    body=body
)

# Parse response
response_body = json.loads(response['body'].read())
print(response_body['content'][0]['text'])

Using the Converse API (Recommended)

The Converse API provides a unified interface across all models:

import boto3

bedrock = boto3.client('bedrock-runtime', region_name='us-east-1')

response = bedrock.converse(
    modelId="anthropic.claude-3-sonnet-20240229-v1:0",
    messages=[
        {
            "role": "user",
            "content": [{"text": "What is AWS Bedrock?"}]
        }
    ],
    inferenceConfig={
        "maxTokens": 1024,
        "temperature": 0.7
    }
)

print(response['output']['message']['content'][0]['text'])

Benefit: Switch models by changing modelId without changing code structure.

Bedrock Knowledge Bases (RAG)

Knowledge Bases let you connect foundation models to your own data using Retrieval-Augmented Generation (RAG).

How It Works

A Knowledge Base turns a plain question into a grounded answer by retrieving your own documents before the model responds. The animated flow below traces a single query through the four stages Bedrock runs for you.

Supported Data Sources

• Amazon S3 (PDF, TXT, MD, HTML, DOC, CSV)
• Web crawlers
• Confluence
• Salesforce
• SharePoint

Creating a Knowledge Base

import boto3

bedrock_agent = boto3.client('bedrock-agent', region_name='us-east-1')

# Create knowledge base
response = bedrock_agent.create_knowledge_base(
    name='company-docs-kb',
    roleArn='arn:aws:iam::123456789:role/BedrockKBRole',
    knowledgeBaseConfiguration={
        'type': 'VECTOR',
        'vectorKnowledgeBaseConfiguration': {
            'embeddingModelArn': 'arn:aws:bedrock:us-east-1::foundation-model/amazon.titan-embed-text-v2:0'
        }
    },
    storageConfiguration={
        'type': 'OPENSEARCH_SERVERLESS',
        'opensearchServerlessConfiguration': {
            'collectionArn': 'arn:aws:aoss:us-east-1:123456789:collection/abc123',
            'vectorIndexName': 'bedrock-kb-index',
            'fieldMapping': {
                'vectorField': 'embedding',
                'textField': 'text',
                'metadataField': 'metadata'
            }
        }
    }
)

Bedrock Agents

Agents enable foundation models to take actions by connecting to external tools and APIs.

Example: Customer Service Agent

An agent can:

1. Look up customer orders in your database
2. Check inventory status via API
3. Create support tickets
4. Send confirmation emails

Agent Architecture

┌─────────────────────────────────────────────────────────────┐
│                        User Input                            │
└─────────────────────────────────────────────────────────────┘
                              │
                              ▼
┌─────────────────────────────────────────────────────────────┐
│                      Bedrock Agent                           │
│  ┌─────────────────────────────────────────────────────┐    │
│  │              Foundation Model (Claude)               │    │
│  │         Reasons about what actions to take           │    │
│  └─────────────────────────────────────────────────────┘    │
│                              │                               │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐       │
│  │ Action Group │  │ Action Group │  │ Knowledge    │       │
│  │ (Lambda)     │  │ (API Schema) │  │ Base         │       │
│  └──────────────┘  └──────────────┘  └──────────────┘       │
└─────────────────────────────────────────────────────────────┘
                              │
                              ▼
┌─────────────────────────────────────────────────────────────┐
│                    Final Response                            │
└─────────────────────────────────────────────────────────────┘

Guardrails: Control Model Outputs

Guardrails let you define policies to filter harmful content and protect sensitive data.

Guardrail Capabilities

Feature	Description
Content filters	Block hate, violence, sexual content, etc.
Denied topics	Prevent discussion of specific topics
Word filters	Block specific words or phrases
PII detection	Mask or block personal information
Contextual grounding	Reduce hallucinations with source verification

Creating a Guardrail

import boto3

bedrock = boto3.client('bedrock', region_name='us-east-1')

response = bedrock.create_guardrail(
    name='customer-support-guardrail',
    description='Guardrail for customer support chatbot',
    contentPolicyConfig={
        'filtersConfig': [
            {'type': 'HATE', 'inputStrength': 'HIGH', 'outputStrength': 'HIGH'},
            {'type': 'VIOLENCE', 'inputStrength': 'HIGH', 'outputStrength': 'HIGH'},
        ]
    },
    sensitiveInformationPolicyConfig={
        'piiEntitiesConfig': [
            {'type': 'CREDIT_DEBIT_CARD_NUMBER', 'action': 'BLOCK'},
            {'type': 'US_SOCIAL_SECURITY_NUMBER', 'action': 'BLOCK'},
        ]
    },
    blockedInputMessaging='I cannot process this request.',
    blockedOutputsMessaging='I cannot provide this information.'
)

Model Fine-Tuning

Bedrock supports fine-tuning select models with your own data to improve performance on specific tasks.

Supported Models for Fine-Tuning

• Amazon Titan Text
• Cohere Command
• Meta Llama 2 (select variants)

Fine-Tuning Process

1. Prepare training data - JSONL format with prompt/completion pairs
2. Upload to S3 - Training data in your bucket
3. Create fine-tuning job - Specify base model and hyperparameters
4. Deploy custom model - Use via Provisioned Throughput

Training Data Format

{"prompt": "Summarize this support ticket:", "completion": "Customer reports login issue..."}
{"prompt": "Summarize this support ticket:", "completion": "User cannot reset password..."}

Best Practices

1. Start with Smaller Models

Use Claude 3 Haiku or Titan Text for development and testing. Move to larger models only when needed for production quality.

2. Implement Caching

Cache common responses to reduce costs:

import hashlib

def get_cached_or_call(prompt, cache):
    cache_key = hashlib.md5(prompt.encode()).hexdigest()
    if cache_key in cache:
        return cache[cache_key]

    response = bedrock.converse(...)
    cache[cache_key] = response
    return response

3. Use Streaming for Long Responses

response = bedrock.converse_stream(
    modelId="anthropic.claude-3-sonnet-20240229-v1:0",
    messages=[{"role": "user", "content": [{"text": "Write a long story"}]}]
)

for event in response['stream']:
    if 'contentBlockDelta' in event:
        print(event['contentBlockDelta']['delta']['text'], end='')

4. Monitor Costs

Set up CloudWatch alarms for Bedrock metrics:

• InvocationCount - Track usage volume
• InvocationLatency - Monitor response times
• TokenCount - Watch token consumption

5. Use VPC Endpoints for Security

aws ec2 create-vpc-endpoint \
  --vpc-id vpc-123456 \
  --service-name com.amazonaws.us-east-1.bedrock-runtime \
  --vpc-endpoint-type Interface

Bedrock vs OpenAI vs Direct Anthropic

Factor	AWS Bedrock	OpenAI API	Anthropic Direct
Model variety	Multiple providers	OpenAI only	Claude only
AWS integration	Native	Manual	Manual
Enterprise compliance	Strong	Developing	Developing
Pricing	Comparable	Comparable	Often cheaper
Fine-tuning	Limited models	GPT-3.5/4	Not available
Setup complexity	AWS knowledge needed	Simple API key	Simple API key
Which should I use / when	You're already on AWS and need VPC, IAM, or compliance controls	You want the fastest prototype and only need OpenAI models	You want the lowest Claude price and don't need AWS integration

Getting Started Checklist

1. Enable Bedrock in your AWS account
2. Request model access for the models you need
3. Set up IAM permissions for your users/services
4. Start with Converse API for model-agnostic code
5. Test with Haiku/Titan before using expensive models
6. Add Guardrails for production deployments
7. Monitor costs with CloudWatch and billing alerts

AWS Bedrock lowers the barrier to building production AI applications while providing enterprise-grade security and compliance. Start experimenting with the playground in the AWS console, then move to the API for production workloads.