AWS Learning Material Certification Cheatsheets
AIF-C01 Domain 3 28% domain

Task 3.1: Describe design considerations for applications that use foundation models (FMs)

Applications of Foundation Models · 3,462 words · source: Certified-AI-Practitioner-AIF-C01/domain-3/task-3-1-cheat-sheet.md

Domain 3: Applications of Foundation Models

Task Statement 3.1: Describe design considerations for applications that use foundation models (FMs)

Domain 3 is "Applications of Foundation Models" and represents 28% of the scored AIF-C01 exam content. Task 3.1 focuses on practical design choices for FM-powered applications: selecting a model, controlling inference, using RAG, choosing vector storage, understanding customization tradeoffs, and recognizing where AI agents fit.

Official Study Path

Use these in order:

  1. AWS Skill Builder: AWS Artificial Intelligence Practitioner Learning Plan
  2. AWS Skill Builder: Exam Prep Plan: AWS Certified AI Practitioner (AIF-C01)
  3. AWS Skill Builder: Domain 3 Review: AWS Certified AI Practitioner
  4. AWS Skill Builder: Domain 3 Practice: AWS Certified AI Practitioner
  5. AWS Exam Guide: Content Domain 3, Task Statement 3.1
  6. AWS Docs: Amazon Bedrock, Knowledge Bases, Agents, model customization, prompt caching, and vector database guidance

Exam Objective Map

You should be able to answer questions about:

Objective What to know for the exam
FM selection criteria Cost, modality, latency, multilingual support, model size, model complexity, customization support, context length, output length, prompt caching, tool/function support, regional availability
Inference parameters Temperature, top_p/top_k, max output tokens, input/output length, stop sequences, deterministic vs creative output
RAG What RAG is, why it improves relevance, how Bedrock Knowledge Bases supports it, when to use it instead of fine-tuning
Vector databases How embeddings are stored and searched; which AWS services can support vector storage
Customization tradeoffs In-context learning, RAG, fine-tuning, continued pre-training, distillation, pre-training
AI agents What agents do, how they combine FMs, user input, data sources, tools, APIs, and knowledge bases

One-Minute Mental Model

An FM application is not just "call a model." It is a system:

  1. Business goal: What task must the user complete?
  2. Model choice: Which FM has the required modality, quality, latency, language, context window, and cost profile?
  3. Prompt and context: What instructions, examples, and retrieved facts does the model need?
  4. Inference controls: Should output be deterministic, creative, short, long, strict, or exploratory?
  5. Data grounding: Does the app need current, proprietary, or source-cited information? If yes, use RAG.
  6. Vector search: Where will embeddings and chunks be stored and retrieved?
  7. Customization: Is prompting/RAG enough, or does the model need fine-tuning, continued pre-training, or distillation?
  8. Agent behavior: Does the app need to take actions or call tools/APIs?
  9. Measurement: Does the app meet business goals at acceptable cost, latency, quality, and risk?

1. Selecting a Foundation Model

Do not look for the "best" model in general. Look for the best model for the use case and constraints.

Criterion Ask this Exam clue
Modality Does the input/output involve text, image, embeddings, audio, video, or multimodal data? Image generation needs an image model; semantic search needs an embedding model; document QA often needs text plus embeddings
Quality vs cost Is the task simple classification or complex reasoning/generation? Smaller models are often cheaper and faster; larger models can improve reasoning and quality
Latency Is this interactive, batch, or back-office? Chatbots and agents need lower latency; offline analysis can tolerate more delay
Multilingual support Does the application serve non-English users or cross-language retrieval? Choose a model with strong multilingual capability or multilingual embeddings
Context window How much input must the model consider? Long policies, contracts, logs, or retrieved documents need larger context windows or RAG
Output length Does the app need short answers, summaries, long reports, or code? Output tokens affect latency, cost, and quota usage
Customization support Does the model support fine-tuning or other customization in Bedrock? Not every model supports every customization method
Prompt caching Is a large static prompt reused across calls? Prompt caching can reduce latency and input token cost for supported models
Tool use / agents Must the app invoke APIs or complete business actions? Use an agent design when the model must orchestrate tools, APIs, data, and conversation
Region and availability Is the model available in the needed AWS Region? Bedrock model support varies by Region and API
Governance Are there security, privacy, compliance, or responsible AI requirements? Choose managed services and controls that support enterprise governance

Exam Pattern

If the question says "lowest cost and low latency for a simple task," favor a smaller/faster model or routing approach.

If it says "highest quality for complex reasoning," favor a more capable model and evaluate cost/latency tradeoffs.

If it says "answers must use company documents and cite sources," favor RAG with a knowledge base, not model pre-training.

If it says "same long system prompt and policy text are sent repeatedly," consider prompt caching.

2. Inference Parameters

Inference parameters influence how a model generates responses. Defaults and parameter names can vary by model, but the exam expects the concepts.

Parameter Lower value tends to Higher value tends to Use low when Use high when
Temperature More predictable, focused, repeatable More random, diverse, creative Facts, classification, extraction, compliance answers Brainstorming, creative writing, diverse suggestions
top_p Restrict token choices to more likely options Allow broader token choices Need stable output Need varied output
top_k Sample from fewer likely tokens Sample from more possible tokens Need constrained responses Need diversity
max output tokens / max_tokens Shorter output, lower cost/latency Longer output, higher cost/latency Short answers, labels, JSON Summaries, reports, long explanations
Stop sequences End output at specific markers N/A Structured output or preventing extra text Usually not applicable

Must-Know Effects

  • Lower temperature usually means more deterministic responses.
  • Higher temperature usually means more creative or varied responses.
  • Longer output limits increase potential cost and latency.
  • Input length plus output length must fit the model context window.
  • Setting max_tokens too high can reserve more quota than needed; setting it too low can truncate the answer.
  • AWS documentation notes that model-specific defaults and ranges vary, so always check the model documentation in real projects.

Exam Traps

  • Temperature does not make a model more accurate by itself.
  • More tokens do not guarantee better answers.
  • A larger model is not always the right model if cost or latency is the priority.
  • Changing both temperature and top_p at the same time can make behavior harder to reason about; tune one sampling control at a time in practice.

3. Retrieval Augmented Generation (RAG)

RAG combines retrieval with generation. Instead of relying only on the FM's general training, the application retrieves relevant information from your data and includes it as context for the model.

RAG Flow

  1. Ingest source data, such as documents, FAQs, manuals, tickets, web pages, or policies.
  2. Split content into chunks.
  3. Convert chunks into embeddings with an embedding model.
  4. Store embeddings and metadata in a vector store.
  5. At query time, embed the user query.
  6. Retrieve the most relevant chunks.
  7. Add retrieved context to the prompt.
  8. Generate an answer, optionally with citations.

When to Use RAG

Use RAG when:

  • Answers need current or proprietary information.
  • The model must cite or ground responses in source material.
  • You want to reduce hallucinations by supplying relevant context.
  • You need domain-specific answers without changing model weights.
  • Source data changes often.
  • You need cheaper and faster iteration than fine-tuning.

Do not default to RAG when:

  • The task is simple and needs no external facts.
  • The required knowledge is already stable and included in the prompt.
  • The data is poor quality, untrusted, or irrelevant.
  • The problem is mainly output style or format rather than factual grounding.

Business Applications

Use case Why RAG fits
Customer support assistant Retrieves product docs, policies, and troubleshooting steps
Enterprise search Answers natural-language questions from internal documents
Legal or compliance assistant Grounds answers in approved policy and source citations
Healthcare or financial knowledge assistant Retrieves controlled, domain-specific reference material
Field service assistant Uses manuals, maintenance logs, and parts catalogs
HR assistant Answers from employee handbooks and benefits documents

Amazon Bedrock Knowledge Bases

Amazon Bedrock Knowledge Bases helps build RAG applications by connecting data sources, generating embeddings, storing vectors, retrieving relevant information, and augmenting prompts. A key exam detail is that Knowledge Bases can include citations so users can check source material.

4. Embeddings and Vector Databases

Embeddings are numeric vector representations of content. Similar meanings should have similar vectors. Vector databases/indexes let applications retrieve semantically similar content, which is the retrieval part of RAG.

AWS Vector Storage Options to Recognize

Service Exam-level role
Amazon OpenSearch Service / OpenSearch Serverless Vector search for semantic retrieval; useful for search-heavy RAG workloads
Amazon Aurora PostgreSQL Relational database plus vector storage with pgvector; useful when app data and vector search belong close to relational data
Amazon RDS for PostgreSQL with pgvector Managed PostgreSQL option for storing and querying vectors when you want PostgreSQL compatibility
Amazon Neptune Analytics GraphRAG and graph-based retrieval where relationships between entities matter
Amazon S3 Vectors Cost-optimized vector storage and querying at scale without provisioning infrastructure

Also recognize that Bedrock Knowledge Bases can integrate with third-party vector stores such as Pinecone, Redis Enterprise Cloud, and MongoDB Atlas, but the exam objective examples emphasize AWS services.

Choosing a Vector Store

Need Strong candidate
Search-first RAG and semantic search OpenSearch Serverless / OpenSearch Service
Existing relational data and SQL workflows Aurora PostgreSQL or RDS for PostgreSQL with pgvector
Relationship-heavy retrieval, entity networks, graph context Neptune Analytics / GraphRAG
Cost-optimized managed vector storage Amazon S3 Vectors
Fully managed RAG orchestration Amazon Bedrock Knowledge Bases

Exam Traps

  • A vector database stores embeddings, not the FM itself.
  • Embeddings are used for similarity search, not text generation.
  • RAG updates knowledge by changing retrieved data, not by retraining the FM.
  • Vector dimensions must match the embedding model requirements.

5. Customization Tradeoffs

Start with the least expensive, least invasive method that meets the requirement. Move to heavier customization only when the lighter option fails.

Approach What changes Best for Cost/complexity Exam signal
Prompt engineering Prompt only Instructions, format, tone, examples Lowest "Improve response style or format quickly"
In-context learning Prompt includes examples Few examples guide behavior Low "Use examples in the prompt"
RAG Retrieved context Factual grounding, changing/private data Low to medium "Use company docs, cite sources, keep answers current"
Fine-tuning Model weights adjusted with labeled examples Consistent task behavior, style, classification, domain patterns Medium to high "Model must learn repeated task patterns from examples"
Continued pre-training Model exposed to domain corpus Broad domain adaptation High "Large domain corpus; adapt model knowledge/language"
Distillation Smaller student model learns from larger teacher Lower latency/cost while preserving quality Medium to high "Need cheaper/faster model similar to larger model"
Pre-training from scratch Entire model trained from large corpus Rare, very specialized FM creation Highest "Build a new foundation model"

Practical Ranking

For most exam scenarios:

  1. Try prompt engineering for behavior, format, and instructions.
  2. Use RAG for proprietary, current, or source-grounded knowledge.
  3. Use fine-tuning for repeated task behavior or domain-specific output patterns.
  4. Use distillation when a large model works but is too slow or expensive.
  5. Use continued pre-training or pre-training only for very large, specialized investments.

Cost Concepts

  • Token-based inference cost depends on input tokens, output tokens, and sometimes cached token read/write pricing.
  • Fine-tuning cost includes training tokens processed and model storage.
  • More training epochs process the dataset more times and increase customization cost.
  • RAG adds storage, ingestion, embedding, and retrieval cost, but avoids retraining for frequent knowledge updates.
  • Distillation can increase upfront customization work but reduce runtime cost and latency.

6. Prompt Caching

Prompt caching is useful when large, static prompt content is reused across requests. Examples include a long system prompt, policy document, tool schema, or document context repeatedly sent with user-specific questions.

Know this:

  • It can reduce response latency and input token cost for supported Bedrock models.
  • Cache hits require the cached prompt prefix to remain stable.
  • It is useful for workloads with long repeated context.
  • It is not a substitute for RAG when the app must search a large knowledge base.
  • Cached token reads, cached token writes, input tokens, and output tokens can be billed differently.

7. AI Agents

An AI agent uses an FM to reason over user input and orchestrate actions. In Amazon Bedrock, agents can connect user conversations, FMs, data sources, software applications, APIs, and knowledge bases.

Agent vs Chatbot vs RAG

Pattern What it does Choose when
Basic FM chatbot Generates responses from prompt/context User only needs conversation or text generation
RAG assistant Retrieves knowledge, then generates grounded answers User needs answers from enterprise or current data
AI agent Plans and takes actions using tools/APIs/data User needs the system to complete tasks, not just answer

Agent Business Applications

Use case Agent action
IT support Check documentation, open a ticket, run workflow
Travel assistant Search options, compare policies, create booking request
Sales operations Retrieve account context, update CRM, draft follow-up
Claims processing Gather claim data, check policy, route for review
Procurement Check vendor rules, create purchase request, notify approver

Agent Design Considerations

  • Tools/action groups: What APIs can the agent call?
  • Permissions: What is the agent allowed to do?
  • Knowledge: Does it need RAG through a knowledge base?
  • Human approval: Which actions require review?
  • Observability: Can you trace decisions, tool calls, errors, and outputs?
  • Guardrails: How do you prevent unsafe, unauthorized, or irrelevant actions?
  • Cost and latency: Multi-step agent workflows can call models and tools multiple times.

8. Decision Shortcuts for Exam Questions

Scenario Best answer pattern
Need accurate answers from internal documents Use RAG with Amazon Bedrock Knowledge Bases
Need source references Use RAG with citations
Need semantic search over text chunks Use embeddings plus vector database
Need relational data plus vector search Use Aurora PostgreSQL or RDS for PostgreSQL with pgvector
Need graph relationships in retrieval Use Neptune Analytics / GraphRAG
Need lower latency and cost for repeated long prompt prefix Use prompt caching
Need creative brainstorming Increase temperature cautiously
Need deterministic extraction/classification Lower temperature and constrain output
Need shorter output and lower cost Reduce max output tokens
Need model to perform actions through APIs Use AI agents
Need company-specific style or repeated output pattern Consider fine-tuning
Need current/private knowledge without retraining Use RAG
Large model quality is good but too expensive Consider distillation

9. Common Wrong Answers

  • Use fine-tuning just to add frequently changing company documents.
  • Use a bigger model when the requirement is lower cost and latency.
  • Increase temperature to make factual answers more accurate.
  • Store raw documents in a vector database without embeddings.
  • Use RAG to change the model's writing style when prompt templates would be enough.
  • Use prompt caching for unrelated prompts that do not share a stable prefix.
  • Use an agent when the app only needs one grounded answer and no actions.
  • Ignore input/output token length when estimating cost and latency.

10. Mini Flashcards

Q: What is the core purpose of RAG? A: Retrieve relevant external context and use it to generate more accurate, grounded responses.

Q: What AWS service provides managed RAG capabilities for Bedrock applications? A: Amazon Bedrock Knowledge Bases.

Q: What stores embeddings for similarity search? A: A vector database or vector index.

Q: What parameter most directly controls randomness? A: Temperature.

Q: What happens when max output tokens is too low? A: The response can be truncated.

Q: When should you choose RAG over fine-tuning? A: When the model needs current, private, or source-cited knowledge that changes over time.

Q: When should you choose fine-tuning over RAG? A: When the model needs to learn consistent behavior, task patterns, or style from examples.

Q: What is model distillation? A: Training a smaller student model to approximate a larger teacher model for lower cost or latency.

Q: What is prompt caching best for? A: Reused long static prompt prefixes.

Q: What is an AI agent? A: An FM-powered system that can reason over inputs and orchestrate tools, APIs, data sources, and workflows to complete actions.

11. Practice Questions

  1. A company wants a support assistant that answers only from its product manuals and includes source references. What design should it use?

    • Answer: RAG with Amazon Bedrock Knowledge Bases and citations.

  2. A chatbot gives inconsistent JSON for a low-creativity extraction task. What parameter change is most appropriate?

    • Answer: Lower temperature and constrain the output format.

  3. A team sends the same long policy text in every request, followed by different user questions. What feature can reduce latency and input token cost?

    • Answer: Prompt caching, if the selected model supports it.

  4. A company needs semantic search over internal documents. What must be created from the document chunks?

    • Answer: Embeddings stored in a vector database or vector index.

  5. A large model gives high-quality answers, but production latency and cost are too high. Which customization approach can help?

    • Answer: Distillation to a smaller student model.

  6. A model needs to call a CRM API, retrieve account context, and create a follow-up task. What application pattern is this?

    • Answer: AI agent.

  7. A knowledge base has constantly changing policies. Should the company fine-tune the model on every policy update?

    • Answer: No. Use RAG so retrieval uses updated source data without retraining the FM.

  8. A team needs vector search close to existing relational data. Which AWS database options should it recognize?

    • Answer: Amazon Aurora PostgreSQL or Amazon RDS for PostgreSQL with pgvector.

12. Last-Day Review Checklist

  • I can explain model selection tradeoffs: cost, modality, latency, language, context length, output length, customization, and prompt caching.
  • I know low vs high temperature behavior.
  • I understand that max output tokens affects cost, latency, quota usage, and truncation risk.
  • I can define RAG and describe the Bedrock Knowledge Bases flow.
  • I can distinguish embeddings, vector stores, chunks, metadata, and citations.
  • I know AWS vector storage options: OpenSearch, Aurora PostgreSQL, RDS PostgreSQL with pgvector, Neptune Analytics, and S3 Vectors.
  • I can compare prompt engineering, in-context learning, RAG, fine-tuning, continued pre-training, distillation, and pre-training.
  • I can explain why RAG is usually better than fine-tuning for changing proprietary knowledge.
  • I can explain what AI agents do and when to use them.
  • I can spot wrong answers that overuse fine-tuning, larger models, or agents.

Official Sources