Welcome to the Basics of GenAI Foundation Models with Amazon Bedrock course! This is your first lesson in an exciting learning journey that will take you from complete beginner to building sophisticated AI-powered applications using AWS services. This learning path has been developed in partnership with Amazon and AWS to provide you with hands-on, practical experience with cutting-edge generative AI technologies.

Before we begin, let's make sure you have the necessary background knowledge. We expect you to have familiarity with Python programming, including functions, OOP, and error handling. You should also understand fundamental cloud computing concepts and have some experience with APIs, though we'll explain AWS-specific details as we go.

This learning path consists of four comprehensive courses that will guide you through building complete AI applications:

1. Basics of GenAI Foundation Models with Amazon Bedrock: Master the fundamentals of interacting with AI models, configuring their behavior, creating effective prompts, and implementing safety measures.
2. Managing Data for GenAI with Bedrock Knowledge Bases: Learn to store, process, and retrieve documents using vector databases and implement retrieval-augmented generation.
3. Putting Bedrock Models to Action with Strands Agents: Build conversational agents that can perform real-world tasks using tools and external data sources.
4. Deploying Agents to AWS with Bedrock AgentCore: Scale your agents to production environments with enterprise-grade deployment and memory management.

By completing this learning path, you'll be able to design, build, and deploy production-ready AI applications that can understand natural language, access external knowledge, perform complex tasks, and maintain context across conversations. Today, we'll start with the foundation: sending your first message to Amazon Bedrock and understanding how AI models respond to your requests.

AWS Bedrock represents Amazon's approach to democratizing artificial intelligence by providing easy access to powerful foundation models through a simple cloud interface. Think of Bedrock as a comprehensive AI marketplace where you can access models from leading companies like Anthropic, AI21 Labs, Cohere, Meta, and Amazon itself without the complexity of managing infrastructure or training models from scratch. Rather than spending months or years developing your own AI models, you can immediately start building intelligent applications using state-of-the-art foundation models.

What makes Bedrock particularly valuable is its serverless architecture: you simply send requests and receive responses without worrying about scaling, maintenance, or model updates. The service operates on a pay-as-you-go model, meaning you only pay for the tokens you process, making it cost-effective for both experimentation and production workloads. This approach removes the traditional barriers to AI adoption, allowing developers and businesses to focus on creating value rather than managing complex AI infrastructure.

Bedrock excels across several key areas that cover the most common AI use cases in modern applications. Text generation capabilities allow you to create content, write emails, generate product descriptions, and produce marketing copy at scale. Conversational AI features enable you to build sophisticated chatbots and virtual assistants that can maintain context and provide helpful responses. Text analysis functionality helps you process documents, extract insights, summarize content, and understand sentiment from large volumes of text.

Beyond traditional text processing, Bedrock also offers multimodal capabilities that extend into working with images and code. You can generate images from text descriptions, analyze visual content, and even get assistance with programming tasks. This comprehensive range of capabilities means that a single service can power multiple aspects of your application, from customer service chatbots to automated content generation, reducing the complexity of integrating multiple AI services.

Before we can interact with any AWS service, we need to understand Identity and Access Management (IAM), which is AWS's system for controlling who can access which services and what actions they can perform. Think of IAM as the security foundation of your AWS environment—it determines whether your applications, users, or services have the right to perform specific operations. IAM works through a combination of users, roles, and policies that define permissions in a granular and secure manner.

IAM operates on the principle of least privilege, meaning you should only grant the minimum permissions necessary for a task to be completed successfully. This security approach protects your resources while ensuring your applications can function properly. When working with Bedrock, IAM becomes crucial because it controls not only whether you can access the service, but also which models you can use and what operations you can perform with them.

You don't need to worry about configuring AWS credentials while working in this course — everything is already set up for you in the CodeSignal environment. All the necessary permissions and credentials are handled behind the scenes, so you can focus on learning Bedrock without any extra setup.

However, if you ever want to use Bedrock from your own computer, you'll need to configure your environment so that AWS can verify your identity and permissions. To use AWS services like Bedrock, you need to provide your AWS credentials to authenticate with AWS. There are multiple ways to configure these credentials depending on your setup and preferences, and the AWS SDK will automatically look for credentials in several standard locations.

If you don't already have AWS credentials, you can create them through the AWS Management Console. For detailed information about the various ways to configure your credentials and region settings, refer to the AWS documentation on configuring credentials and how to get credentials. Remember, you only need to worry about this setup if you're working on your own machine — in this course, you can skip these steps and get started right away!

For Bedrock specifically, the most important permission you'll need is bedrock:InvokeModel, which allows your code to send requests to foundation models and receive responses. In production environments, you'd create specific IAM roles with minimal required permissions, but for learning and development purposes, having general Bedrock access through your AWS credentials is sufficient. You might also need additional permissions like bedrock:GetFoundationModel if you want to retrieve information about available models or their capabilities.

Additionally, model access must be explicitly enabled in the Bedrock console, which is separate from IAM permissions. Not all models are available by default; some require you to request access through AWS, particularly newer or more powerful models. You'll find these model access settings in the Bedrock console under "Model access," where you can enable the specific models you want to use. The region you choose also matters significantly because model availability varies by AWS region—US East (N. Virginia, us-east-1) typically has the broadest selection of models, making it a safe choice for development work.

Let's begin building our connection to AWS Bedrock. The foundation of any Bedrock interaction starts with creating a client using the boto3 library, which is AWS's official Python SDK.

This code creates a Bedrock Runtime client that will handle all our communications with the Bedrock service. The "bedrock-runtime" service name specifically refers to the runtime API, which is what we use for actual model inference, as opposed to the management APIs used for administrative tasks. The client will automatically use your AWS credentials from your environment, whether that's through AWS CLI configuration, environment variables, or IAM roles.

Next, we need to specify which AI model we want to interact with. Each model in Bedrock has a unique identifier that tells the service exactly which model and version to use:

The model ID follows a specific format that includes the provider (e.g. Anthropic), the model family (e.g. Claude Sonnet), version information, and regional availability. This particular identifier points to Claude 4 Sonnet, one of Anthropic's most capable models available through Bedrock. Different models have varying token pricing, with more advanced models like Claude 4 Sonnet typically costing more per token than simpler models, so consider your budget and performance requirements when choosing. The structure of this ID ensures you're always using the exact model version you intend, preventing unexpected behavior from automatic model updates.

Bedrock's message structure mimics natural conversation patterns. Each message in the conversation has a role and content, similar to how you might structure a chat between a user and an assistant. The content is wrapped in an array format, which allows for future expansion to include images, documents, or other media types alongside text. This flexible structure is key to Bedrock's ability to handle increasingly complex multimodal interactions.

The Converse API is Bedrock's standardized interface for interacting with different foundation models. Rather than learning different APIs for each model provider, the Converse API provides a unified way to communicate with any supported model, whether it's Claude from Anthropic, Llama from Meta, or Titan from Amazon. This API handles the complexity of translating your requests into each model's specific format and translating responses back into a consistent structure.

Let's create our first message to send to the AI model. The message structure follows a specific format that tells Bedrock both what we're asking and who is asking it:

This structure represents a single conversation turn where we (the "user") are asking the AI to explain AWS Bedrock to a beginner:

• messages array: Contains the entire conversation history, with each element representing one turn in the dialogue.
• Individual message object: Each message has two required keys:
  • role: Identifies the speaker, typically "user" (your input) or "assistant" (the AI's response);
  • content: An array containing the actual message content.
• content array: Holds the message payload and supports multiple content types:
  • Text content: Objects with a "text" key containing the actual text string;

With our client configured and message prepared, we can now make our first call to a Bedrock model:

The converse method takes our model ID and messages array and sends them to the specified model for processing. The call is synchronous, meaning our code will wait for the response before continuing. The try-except block is crucial because network calls can fail for various reasons: network connectivity issues, invalid model IDs, insufficient permissions, or service limitations. Proper error handling ensures your application can gracefully handle these situations.

When Bedrock returns a response, it arrives in a structured format that mirrors the input message structure. We need to extract the actual text content from this nested structure carefully and safely:

This code navigates through the nested response structure safely using the get() method, which prevents errors if any expected keys are missing:

• Response structure: The response contains nested dictionaries: response["output"]["message"]["content"] leads to an array of content parts.
• Safe navigation: Using .get() methods prevents crashes if any key is missing, returning empty dictionaries or lists as fallbacks
• Content extraction: The content array contains multiple parts (usually just one for text), where each part is a dictionary with a "text" key.
• Text filtering: The list comprehension extracts text from each content part and filters out any non-dictionary items for safety.
• Final assembly: We join all text chunks together and strip any extra whitespace to get a clean, readable response.

When we run our complete script, Bedrock processes our question and provides a comprehensive explanation. The AI's response demonstrates sophisticated reasoning capabilities, not only answering our question but structuring the information logically with practical examples. Here's what the actual output looks like:

This response showcases the model's ability to provide structured, informative content that's both comprehensive and accessible to beginners. The formatting, examples, and balanced perspective on pros and cons demonstrate the sophisticated capabilities available through Bedrock's foundation models.

Congratulations! You've successfully completed your first interaction with Amazon Bedrock and witnessed the power of foundation models in action. We've covered the essential components: setting up the Bedrock client with proper IAM permissions, understanding the message structure, using the Converse API to communicate with AI models, and safely processing the responses to extract meaningful content.

The foundation you've built in this lesson sets the stage for everything we'll create throughout this course and the entire learning path. In the upcoming practice section, you'll get hands-on experience implementing these concepts yourself, reinforcing your understanding through practical application. As we continue through the course, we'll explore how to fine-tune model behavior, craft more sophisticated prompts, and implement safety measures to ensure reliable AI interactions. Happy coding!