Enterprise Transition • Azure ➔ AWS GenAI & Agents

Agentic AI on AWS Mastery Roadmap

A battle-tested curriculum engineered for Azure AI Engineers (App Service, Blob, Postgres pgvector, Function Apps, Document Intelligence, Azure AI Search, Azure AI Foundry) translating their mental models into Amazon Bedrock Converse, AgentCore (Harness/Gateway/Runtime), Knowledge Bases, OpenSearch RRF, and Model Context Protocol (MCP).

Architecture & Transition Intent
"Translate Azure AI Engineering skills into AWS Generative AI & Agentic architectures with Amazon Bedrock, AgentCore, MCP, LocalStack, and Serverless pipelines."
AWS Agentic Modules
24
6 progressive architectural stages
Completed Milestones
0
0% completed
Azure ➔ AWS Bridges
10 PaaS Parities
Direct service translation
Foundry Labs
6 Labs Ready
LocalStack ($0) ↔ AWS Prod
AWS Agentic AI Transition Progress 0%
01

Side-by-Side SDK & Architecture Diffs

Compare real-world implementation syntax between the Azure SDK and AWS Boto3 SDK. Understand key paradigm shifts in model calling, tool execution, and RAG retrieval.

Azure OpenAI Python SDK Named Deployment
from openai import AzureOpenAI client = AzureOpenAI( azure_endpoint="https://my-res.openai.azure.com", api_key=os.environ["AZURE_OPENAI_KEY"], api_version="2024-06-01" ) # Must target specific deployment name response = client.chat.completions.create( model="gpt-4o-prod-deployment", messages=[{"role": "user", "content": "Analyze quarterly report"}], tools=[{ "type": "function", "function": {"name": "calc", "parameters": schema} }] )
AWS Bedrock Converse API (boto3) Model ID / Cross-Region Profile
import boto3 client = boto3.client("bedrock-runtime", region_name="us-east-1") # Unified API across Claude 3.7, Nova, Llama 3.3 response = client.converse( modelId="us.anthropic.claude-3-7-sonnet-20250219-v1:0", messages=[{"role": "user", "content": [{"text": "Analyze quarterly report"}]}], inferenceConfig={"maxTokens": 2048, "temperature": 0.2}, toolConfig={"tools": [{ "toolSpec": {"name": "calc", "inputSchema": {"json": schema}} }]} )
Key Mental Model Shift: In Azure, you manage provisioned throughput per named deployment instance. In AWS Bedrock, foundation models are serverless endpoints invoked directly by model ID or geographic cross-region inference profiles (e.g. us.anthropic...) to automatically distribute traffic across regions for higher concurrency limits.
02

PaaS Equivalence Matrix

Quick lookup mapping every key Azure AI & Backend service to its direct AWS counterpart and production engineering considerations.

Azure AI Component AWS Equivalent & Tooling Core Difference & Architectural Guidance
Azure OpenAI Models
Named Model Deployments
 Amazon Bedrock
Converse API (boto3)
 No deployment provisioning needed. Unified converse() / converse_stream() boto3 API across Claude 3.7, Nova, Llama 3.3, and Mistral. Always specify maxTokens explicitly to avoid quota reservation throttling.
Azure AI Foundry Agents
Semantic Kernel / Assistants
 Bedrock AgentCore
Harness, Gateway, Runtime & Memory
 Modular agent framework: Harness (managed config loop), Gateway (exposing OpenAPI & MCP tools), Runtime (ARM64 serverless containers), and Memory (cross-session episodic recall).
Azure AI Search
Vector + Hybrid + Semantic Ranker
 Bedrock Knowledge Bases
OpenSearch Serverless / RRF
 Managed S3 ingestion pipeline syncing into OpenSearch Serverless, Aurora pgvector, or Pinecone with automated chunking, Titan Embeddings V2, and Reciprocal Rank Fusion (RRF) scoring.
Azure Document Intelligence
Form Recognizer & Layout
 Amazon Textract
AnalyzeDocument + Multimodal Vision
 Textract extracts layout tables, key-value forms, and query-answers as structured JSON block graphs. Combined with Claude 3.7 / Nova vision for complex visual diagrams and charts.
Azure Blob Storage
Containers & SAS Tokens
 Amazon S3
Document Lake & Presigned URLs
 Blob containers become S3 Buckets; SAS tokens become S3 Presigned URLs (generated via generate_presigned_url). S3 bucket notifications trigger asynchronous document chunking and vector indexing via SQS/Lambda.
Azure Functions
Event Grid & Blob Triggers
 AWS Lambda + SQS
Event-Driven AI Pipelines
 In AWS production, S3 pushes events to an Amazon SQS queue which throttles and batches events into AWS Lambda chunking workers, preventing concurrency blowouts.
Postgres Flexible Server
pgvector & Cosmos DB
 Aurora Serverless v2
pgvector & Amazon DynamoDB
 Aurora Serverless v2 auto-scales compute with pgvector (HNSW indexing) for relational vector search. Amazon DynamoDB provides ultra-low latency single-digit millisecond key-value storage for agent session history.
Azure Content Safety
Severity Threshold Filters
 Amazon Bedrock Guardrails
Topic, PII & Grounding Filters
 Bedrock Guardrails provides: (1) Blocked topic policies, (2) PII masking with Macie integration, (3) Custom word/regex filters, and (4) Contextual Grounding Checks which mathematically detect hallucinations by comparing output against reference RAG chunks.
Azure Tooling & Extensions
Custom REST Connectors
 Model Context Protocol
aws-mcp & LocalStack MCP
 Anthropic's open MCP standard connects AI agents to live cloud tools. AWS provides the official `aws-mcp` server (sandboxed boto3 execution, live docs), and LocalStack provides the `localstack` MCP server for automated least-privilege IAM policy synthesis.
Azurite (Local Emulator)
Blob / Queue emulation only
 LocalStack Pro (`lstk`)
Full Cloud Emulation ($0 Cost)
 Azurite only emulates basic storage. LocalStack emulates the entire AWS ecosystem (S3, DynamoDB, Lambda, SQS, Bedrock with Ollama, IAM, Secrets Manager, Chaos API) locally on localhost:4566 for zero-cost rapid development and testing.
03

AWS Agentic AI Learning Progression

Follow the 6 structured stages to master Agentic AI on AWS. Filter by focus track or difficulty, check off completed milestones, and click deep dives for hands-on project specs.

Focus Track:
Difficulty:
Search Skills:
STAGE 1

AWS Foundations & Dual-Cloud Emulation

Bridge Azure Blob & Functions to AWS S3 & Lambda. Master zero-cost local prototyping with LocalStack Pro before cloud deployment.

Azure Blob Storage ➔ Amazon S3
Lab 01 Beginner

Transition from Azure Blob Storage containers & SAS tokens to Amazon S3 buckets, multipart uploads, lifecycle transitions (Glacier), and boto3 presigned upload/download URLs.

  • S3 bucket policies vs IAM identity policies
  • Generating presigned upload/download URLs via boto3
  • Multipart uploads for multi-gigabyte document corpora
~6 hours
Azurite ➔ LocalStack Pro (`lstk`)
Foundry Core Beginner

Set up LocalStack Pro (http://localhost:4566) with Ollama for zero-cost local prototyping, local AWS CLI profile configuration, and instant dual-cloud switching.

  • LocalStack container lifecycle management (lstk start)
  • Dynamic AWS_ENDPOINT_URL switching in Python boto3
  • Local Ollama model binding for offline Bedrock simulation
~4 hours
Azure Functions ➔ AWS Lambda + SQS
Lab 03 Intermediate

Build resilient serverless ingestion architectures: S3 file creation events push to Amazon SQS, which buffers batches into AWS Lambda chunking workers.

  • S3 ➔ SQS ➔ Lambda event-source mapping
  • Terraform / OpenTofu IaC deployment with tflocal
  • Dead Letter Queues (DLQ) & concurrency throttling control
~10 hours
Azure RBAC / Managed ID ➔ AWS IAM Roles
Security Intermediate

Master AWS IAM trust relationships, service execution roles, STS temporary sessions, and confused deputy protection (aws:SourceAccount / aws:SourceArn).

  • Trust policies vs Permission policies for Bedrock & Lambda
  • Condition keys: aws:SourceAccount and aws:SourceArn
  • Least-privilege policy generation from runtime denials
~6 hours
STAGE 2

Foundation Models & Bedrock Converse API

Master the unified Bedrock Converse API, streaming chunks with ConverseStream, multi-turn tool calling loops, and Claude 3.7 prompt caching.

Azure OpenAI Chat ➔ Bedrock Converse
Lab 02 Intermediate

Master the unified bedrock-runtime Converse API in Python boto3 across Claude 3.7 Sonnet, Amazon Nova Pro, Llama 3.3, and Mistral without vendor lock-in.

  • Converse vs InvokeModel architectural differences
  • Explicit maxTokens quota reservation mechanics
  • Cross-region inference profile routing (us. prefix)
~10 hours
Azure OpenAI stream=True ➔ ConverseStream
Lab 02 Intermediate

Implement real-time token streaming with converse_stream. Handle contentBlockDelta, messageStop, and extract token usage telemetry on the fly.

  • Iterating response['stream'] event objects
  • Handling partial toolUse input chunks in streams
  • Token latency measurement: Time-To-First-Token (TTFT)
~8 hours
Azure OpenAI Tools ➔ Bedrock `toolConfig`
Lab 02 Intermediate

Build full round-trip tool execution loops: pass tool specifications in toolConfig, catch toolUse blocks, execute Python tools, and send back toolResult.

  • JSON Schema tool parameter definitions
  • Multi-turn dialogue state preservation with tool results
  • Error recovery when tools throw exceptions
~10 hours
Azure Prompt Caching ➔ Bedrock Cache Points
Cost & Latency Advanced

Slash token costs by up to 90% and latency by 80% on Claude 3.7 / 3.5 by inserting prompt caching breakpoints on large document contexts and system instructions.

  • Minimum token threshold requirements (1,024 tokens)
  • 5-minute TTL caching semantics & cache hit verification
  • Diagnosing zero-cache-hit issues (cacheReadInputTokens)
~8 hours
STAGE 3

Document Intelligence & Enterprise RAG

Extract complex documents with Textract, deploy managed Knowledge Bases, implement hand-built hybrid RRF retrieval, and manage session memory with DynamoDB.

Azure Doc Intelligence ➔ Amazon Textract
Document OCR Intermediate

Extract high-fidelity structured data from PDFs, scanned forms, and tables using Amazon Textract AnalyzeDocument, paired with Claude 3.7 / Nova vision for infographic understanding.

  • Textract Forms, Tables & Queries feature types
  • Asynchronous multi-page document processing with S3
  • Multimodal document comprehension with Claude 3.7 / Nova Pro
~10 hours
Azure AI Search Indexer ➔ Bedrock Knowledge Base
Managed RAG Intermediate

Configure fully managed RAG pipelines on AWS: connect S3 data sources to Bedrock Knowledge Bases with automated chunking, Titan Embeddings V2, and OpenSearch Serverless.

  • 7-step KB setup procedure & S3 sync pipelines
  • RetrieveAndGenerate vs Retrieve-only query modes
  • Advanced chunking: Semantic vs Hierarchical vs Fixed
~12 hours
Azure Hybrid RRF ➔ OpenSearch / DynamoDB RRF
Lab 04 Advanced

Build custom hybrid retrieval from scratch: combine dense vector embeddings with BM25 sparse lexical search using Reciprocal Rank Fusion (RRF) algorithms.

  • RRF mathematical formula: sum(1 / (k + rank))
  • DynamoDB chunk indexing & session-memory tables
  • OpenSearch Neural Search hybrid query scoring
~12 hours
Azure Postgres pgvector ➔ Aurora Serverless v2
Vector DB Advanced

Deploy relational vector search on Amazon Aurora Serverless v2 using pgvector (HNSW & IVF-Flat indexes), paired with DynamoDB for ultra-low latency agent memory.

  • HNSW vs IVF-Flat indexing on PostgreSQL
  • Combining relational SQL filters with vector similarity
  • DynamoDB TTL for expiring session contexts
~10 hours
STAGE 4

Autonomous Agents & Bedrock AgentCore

Master the AgentCore ecosystem: Harness managed loops, Gateway tool routing, Runtime ARM64 serverless containers, and LangGraph multi-agent orchestration.

Azure Assistant Service ➔ AgentCore Harness
Next-Gen Bedrock Intermediate

Deploy managed agent loops using Bedrock AgentCore Harness (the successor to classic Bedrock Agents). Declare models, tools, skills, and memory purely as configuration without custom loop code.

  • create-harness declaration & polling status
  • Invoking with runtimeSessionId and message arrays
  • AgentCore CLI (agentcore create/deploy/invoke)
~12 hours
Azure API Connectors ➔ AgentCore Gateway
Enterprise Tooling Advanced

Expose enterprise REST APIs, Lambda microservices, and live Model Context Protocol (MCP) servers directly to agents via AgentCore Gateway with unified authorization.

  • Bridging OpenAPI specs and MCP servers to agent tools
  • Policy enforcement with Cedar rules on Gateway tool calls
  • Agent identity delegation with Entra ID and Cognito
~10 hours
Azure Container Apps ➔ AgentCore Runtime
Serverless Hosting Advanced

Deploy custom agent orchestrations (LangGraph, custom Python loops) as scalable ARM64 serverless containers on Bedrock AgentCore Runtime.

  • ARM64 container build specifications for AgentCore
  • Serverless scaling & multi-tenant agent execution
  • AgentCore Memory: short-term buffer & long-term cross-session
~12 hours
Semantic Kernel Agents ➔ LangGraph on AWS
State Machines Advanced

Build cyclic multi-agent graphs with branching logic, critic nodes, time-travel debugging, and Human-in-the-Loop (HITL) approval checkpoints backed by DynamoDB checkpointers.

  • LangGraph StateGraph definitions with Bedrock models
  • Human-in-the-Loop (HITL) pause & resume mechanisms
  • Multi-agent supervisor-worker collaboration topologies
~14 hours
STAGE 5

Model Context Protocol (MCP) & Sandboxing

Harness official `aws-mcp` tools, LocalStack auto-IAM synthesis, FastMCP custom server development, and sub-second Lambda microVM sandboxing.

Azure CLI / REST ➔ Official AWS MCP Server
Lab 05 Intermediate

Harness the official AWS MCP proxy for sandboxed boto3 Python execution (aws___run_script), live AWS documentation retrieval, and service skill loading.

  • Sandboxed execution with injected call_boto3
  • Searching live AWS official docs directly inside AI chat
  • Loading 23+ procedural skills (Bedrock, IAM, Serverless)
~8 hours
Manual Azure Role Assignment ➔ LocalStack Auto-IAM
Lab 06 Advanced

Use LocalStack MCP (localstack-iam-policy-analyzer) to run scripts under strict IAM enforcement, capture runtime permission denials, and automatically synthesize minimal IAM policies.

  • LocalStack MCP server configuration & tools
  • Automated least-privilege policy generation from logs
  • Managing Cloud Pods state snapshots across environments
~10 hours
Custom Azure Functions ➔ FastMCP Server
Tooling Advanced

Build custom production-grade MCP servers in Python (FastMCP) to expose corporate databases, microservices, and internal APIs to AI agents with Pydantic validation.

  • MCP Primitives: Tools vs Resources vs Prompts
  • Transports: Local stdio vs Stream-based HTTP/SSE
  • FastMCP server definition & JSON-RPC error handling
~10 hours
Azure Container Instances ➔ AWS Lambda Code Runner
Security Advanced

Safely execute untrusted agent-generated Python code by spinning up ephemeral AWS Lambda microVM sandboxes with restricted network access and ephemeral scratch storage.

  • Lambda microVM isolation (Firecracker virtualization)
  • Preventing host filesystem access & token exfiltration
  • Capturing stdout, stderr, and generated artifact charts
~12 hours
STAGE 6

Guardrails, Evaluation, Observability & Resilience

Enforce Bedrock Guardrails, run quantitative RAG Triad benchmarks with Ragas, monitor token metrics via CloudWatch EMF, and test chaos resilience.

Azure Content Safety ➔ Bedrock Guardrails
AI Safety Intermediate

Deploy safety policies: block off-topic queries, mask PII, filter toxic content, and enable Contextual Grounding Checks to mathematically detect hallucinations in RAG outputs.

  • Topic policies, content filters & sensitive PII masking
  • Contextual Grounding checks for RAG hallucination blocking
  • Understanding the CloudWatch Logs PII compliance gap
~10 hours
Azure AI Studio Evals ➔ Ragas / DeepEval on AWS
Quality Advanced

Implement quantitative quality benchmarks: evaluate Faithfulness, Answer Relevance, and Context Precision using Ragas and DeepEval with LLM-as-a-judge pipelines.

  • RAG Triad metrics & synthetic testset generation
  • CI/CD automated regression testing for Bedrock models
  • LLM-as-a-judge position bias and length bias mitigation
~10 hours
Azure App Insights ➔ CloudWatch EMF + X-Ray
Observability Advanced

Track token usage, cost attribution, and multi-agent latency bottlenecks using CloudWatch Embedded Metric Format (EMF) and AWS X-Ray / OpenTelemetry (ADOT).

  • CloudWatch EMF async metric logging without API overhead
  • X-Ray distributed tracing across multi-hop agent pipelines
  • Cost allocation tags & Bedrock inference profile tracking
~8 hours
Azure Chaos Studio ➔ LocalStack Chaos API
Lab 06 Advanced

Simulate real cloud faults. Inject latency and 500 error spikes into S3, DynamoDB, and Bedrock with the LocalStack Chaos API to test boto3 adaptive retry configurations.

  • Configuring boto3 adaptive retries: Config(retries={'mode':'adaptive'})
  • LocalStack Chaos API fault injection & verification
  • Exponential backoff with full jitter against ThrottlingException
~10 hours
Azure ➔ AWS Diagnostic

AI Engineer AWS Readiness Assessment

Select your current Azure AI experience level to receive a tailored starting point and recommended transition path.

1. What is your experience with Azure AI Services & Storage?
Used Blob Storage, Function Apps & Azure OpenAI basic prompts
Built RAG with Azure AI Search, Doc Intelligence & Postgres pgvector
Architected multi-agent loops with Semantic Kernel / Azure AI Foundry
2. How familiar are you with AWS Bedrock & Boto3?
Brand new to AWS and Boto3 Python SDK
Have used basic S3 / Lambda, but new to Bedrock Converse & AgentCore
Familiar with Bedrock InvokeModel, looking for Converse API & AgentCore
3. What is your primary objective in this transition?
Learn the core AWS equivalent services and dual-cloud LocalStack workflow
Build production RAG pipelines with Bedrock Knowledge Bases & OpenSearch RRF
Master Bedrock AgentCore, MCP servers, Guardrails, and Terraform IaC
Recommended Entry Point

Export Your Custom AWS AI Learning Plan

Generates a comprehensive Markdown summary of your Azure background, completed AWS milestones, pending labs, and target weekly study plan ready to paste into your AI pair programming assistant.