AIF-C01 Deep Dive: Amazon Bedrock and Foundation Model Applications (Domains 2 & 3)

If you are preparing for the AWS Certified AI Practitioner (AIF-C01), here is the most important number to remember: 52%. That is the combined weight of Domain 2 (Fundamentals of Generative AI, 24%) and Domain 3 (Applications of Foundation Models, 28%). These two domains alone determine whether you pass or fail. They cover the concepts behind generative AI — transformers, tokenization, embeddings, inference parameters — and the AWS services that bring those concepts to life, particularly Amazon Bedrock. In this deep dive, we break down every major topic in both domains with the detail you need to answer exam questions confidently.

Transformer Architecture Essentials

The transformer architecture, introduced in the 2017 paper "Attention Is All You Need," is the foundation of every modern large language model (LLM). For the AIF-C01 exam, you do not need to understand the mathematics behind transformers, but you must understand the key concepts at a conceptual level.

The core innovation of the transformer is the self-attention mechanism, which allows the model to weigh the importance of every word in a sentence relative to every other word. Unlike older recurrent neural networks (RNNs) that process text sequentially, transformers process all tokens in parallel, making them dramatically faster to train on large datasets.

Transformers come in three flavors, and the exam expects you to know the difference:

Tokenization, Embeddings, and Inference Parameters

Tokenization is the process of breaking input text into smaller units (tokens) that the model can process. A token is not always a word — it can be a word, a subword, or even a single character depending on the tokenizer. For exam purposes, remember that billing for foundation models is typically based on the number of input and output tokens, and that different models may tokenize the same text differently.

Embeddings are numerical vector representations of tokens. Words with similar meanings have embeddings that are close together in vector space. The exam tests whether you understand that embeddings enable semantic similarity search, which is the foundation of RAG (retrieval-augmented generation).

When invoking a foundation model, you control its behavior through inference parameters:

Hallucination occurs when a model generates plausible-sounding but factually incorrect information. The exam tests your knowledge of hallucination mitigation strategies: lowering temperature, using RAG to ground responses in real data, implementing Bedrock Guardrails with grounding checks, and including system prompts that instruct the model to say "I don't know" when uncertain.

Amazon Bedrock Model Families

Amazon Bedrock provides access to multiple foundation model families through a single API. The exam expects you to know which models are available and when to choose each one.

RAG vs Fine-Tuning vs Prompt Engineering

This is one of the most heavily tested concepts on the AIF-C01. You must understand when to use each approach for customizing foundation model behavior.

The decision framework the exam expects: Start with prompt engineering. If the model lacks the required knowledge (e.g., private company data), add RAG. If you need to fundamentally change the model's behavior or output style (e.g., generate responses in a specific medical terminology format), use fine-tuning. The exam loves to test scenarios where candidates choose fine-tuning when RAG is the correct answer — remember that RAG is preferred when you need up-to-date, factual data because it retrieves from a live data source rather than baking knowledge into model weights.

Amazon Bedrock Knowledge Bases

Bedrock Knowledge Bases is AWS's managed RAG implementation. It handles the entire RAG pipeline: ingesting documents, chunking them, creating embeddings, storing them in a vector database, and retrieving relevant chunks at query time.

The RAG pipeline in Bedrock Knowledge Bases follows these steps:

1. Ingest: Upload documents (PDF, TXT, HTML, CSV, DOCX) to an S3 bucket
2. Chunk: Documents are split into smaller segments using configurable chunking strategies (fixed-size, semantic, or hierarchical)
3. Embed: Each chunk is converted into a vector embedding using an embedding model (Titan Embeddings or Cohere Embed)
4. Store: Embeddings are stored in a vector database (Amazon OpenSearch Serverless, Pinecone, or Amazon Aurora with pgvector)
5. Retrieve: At query time, the user's question is embedded and used to find the most semantically similar chunks
6. Generate: Retrieved chunks are added to the prompt context and sent to a foundation model for response generation

# AWS CLI: Create a Bedrock Knowledge Base data source
aws bedrock-agent create-data-source \
  --knowledge-base-id "KB12345678" \
  --name "company-docs" \
  --data-source-configuration '{
    "type": "S3",
    "s3Configuration": {
      "bucketArn": "arn:aws:s3:::my-company-docs"
    }
  }' \
  --vector-ingestion-configuration '{
    "chunkingConfiguration": {
      "chunkingStrategy": "FIXED_SIZE",
      "fixedSizeChunkingConfiguration": {
        "maxTokens": 300,
        "overlapPercentage": 20
      }
    }
  }'

Amazon Bedrock Agents

Bedrock Agents enable agentic workflows — multi-step tasks where the foundation model reasons about what actions to take, invokes APIs or Lambda functions, and iterates until the task is complete. Think of an agent as an LLM with the ability to use tools.

Key concepts for the exam:

• Action Groups: Define the actions an agent can take, backed by Lambda functions or API schemas (OpenAPI)
• Knowledge Base integration: Agents can query Bedrock Knowledge Bases to retrieve information as part of their reasoning
• Orchestration: The agent uses chain-of-thought reasoning to decide which actions to take and in what order
• Session management: Agents maintain conversation context across multiple turns

A typical exam scenario: "A company wants to build a customer service chatbot that can look up order status in a database and answer product questions from documentation." The answer involves a Bedrock Agent with an action group (Lambda function to query the order database) and a Knowledge Base (product documentation in S3).

Amazon Bedrock Guardrails

Bedrock Guardrails provide configurable safeguards that apply to both input prompts and model responses. The exam tests all four guardrail types:

Evaluation Metrics for Foundation Models

The AIF-C01 expects you to know how to evaluate foundation model outputs. Amazon Bedrock provides both automated and human evaluation capabilities. Understanding the key metrics is essential for exam success.

Key exam distinction: ROUGE is recall-oriented (did the summary capture the key ideas from the reference?), while BLEU is precision-oriented (are the generated words accurate compared to the reference?). BERTScore goes beyond word matching to compare semantic meaning. When the exam mentions "evaluating the quality of summarization," the answer is ROUGE. For "evaluating translation quality," it is BLEU.

SageMaker JumpStart for Fine-Tuning

While Bedrock is the primary service for using foundation models, SageMaker JumpStart is the go-to for fine-tuning them. JumpStart provides pre-trained foundation models that you can fine-tune on your own data using SageMaker's managed training infrastructure.

The exam tests when to use Bedrock Custom Models (fine-tuning through Bedrock) vs SageMaker JumpStart:

• Bedrock Custom Models: Simpler, managed fine-tuning through the Bedrock console for supported models. No infrastructure management needed. Best for straightforward customization.
• SageMaker JumpStart: More control over the training process, hyperparameters, and infrastructure. Supports a wider range of models and fine-tuning techniques (full fine-tuning, LoRA, QLoRA). Best for ML teams that need granular control.

# AWS CLI: Invoke a Bedrock model (Claude on Bedrock example)
aws bedrock-runtime invoke-model \
  --model-id "anthropic.claude-3-sonnet-20240229-v1:0" \
  --body '{
    "anthropic_version": "bedrock-2023-05-31",
    "max_tokens": 1024,
    "temperature": 0.3,
    "messages": [
      {
        "role": "user",
        "content": "Explain the difference between RAG and fine-tuning in 3 sentences."
      }
    ]
  }' \
  --content-type "application/json" \
  --accept "application/json" \
  output.json

Practical Examples

To tie these concepts together, here are three realistic exam scenarios and how to think through them:

Scenario 1: A legal firm wants their chatbot to answer questions about their internal policy documents. The documents are updated monthly. Which approach should they use?

Answer: RAG with Bedrock Knowledge Bases. The documents change frequently (ruling out fine-tuning, which would require retraining), and the model needs access to private data (ruling out prompt engineering alone). Set up an S3 bucket with the policy documents, create a Knowledge Base, and sync it monthly.

Scenario 2: A company wants to build a customer service bot that checks order status AND answers product questions. What Bedrock features should they combine?

Answer: Bedrock Agent with an action group (Lambda function to query the order database) and a Knowledge Base (product documentation). The agent orchestrates between the two based on the user's question.

Scenario 3: A healthcare company wants to use a foundation model but must ensure no patient PII is included in prompts or responses. What should they implement?

Answer: Bedrock Guardrails with PII redaction enabled. Configure the guardrail to detect and mask healthcare-specific PII types (names, medical record numbers) in both input and output.

Domains 2 and 3 are where the AIF-C01 exam is won or lost. Master the transformer fundamentals, know the Bedrock model families and their differentiators, understand the RAG-vs-fine-tuning decision framework, and be comfortable with Knowledge Bases, Agents, Guardrails, and evaluation metrics. With this foundation, you will be well-prepared to tackle more than half the exam with confidence.