# Sample Getting Started With Strands Agents Course

> Learn to build AI agents with Strands framework. Covers LLM integration via Amazon Bedrock/Anthropic, AWS service connections, tool implementation with MCP/A2A protocols, and agent evaluation using LangFuse/RAGAS.

- **Type:** MCP server
- **Install:** `agentstack add mcp-aws-samples-sample-getting-started-with-strands-agents-course`
- **Verified:** Yes — security-reviewed for prompt injection and unsafe behavior
- **Seller:** [aws-samples](https://agentstack.voostack.com/s/aws-samples)
- **Installs:** 0
- **Category:** [Cloud & Infrastructure](https://agentstack.voostack.com/c/cloud-infrastructure)
- **Latest version:** 0.1.0
- **License:** MIT-0
- **Upstream author:** [aws-samples](https://github.com/aws-samples)
- **Source:** https://github.com/aws-samples/sample-getting-started-with-strands-agents-course

## Install

```sh
agentstack add mcp-aws-samples-sample-getting-started-with-strands-agents-course
```

Requires the [AgentStack CLI](https://agentstack.voostack.com/docs/cli). Works with Claude Code, Cursor, and any MCP-compatible agent.

## About

# Getting Started with Strands Agents - Complete Learning Path

🎯 **Learning Journey**: Course 1 (Fundamentals) → Course 2 (Advanced MCP, Hooks, Session Management) → Course 3 (Multi-Agent Systems) → Course 4 (Production Deployment)

A comprehensive hands-on learning path for AI agent development using the [Strands Agents framework](https://strandsagents.com/). Build intelligent, multi-agent systems from basic concepts to production-ready implementations with advanced capabilities. All of these courses have free video courses to follow along available at Analytics Vidhya. 

---

## 📚 Learning Path Overview

This repository contains four progressive courses that take you from fundamentals to advanced production-ready implementations:

### **Course 1: Getting Started with Strands Agents**
Foundation course covering basic agent creation, model providers, AWS integration, MCP basics, agent-to-agent communication, and observability fundamentals.

Video Series available [here](https://www.analyticsvidhya.com/courses/getting-started-with-strands-agents-build-your-first-ai-agent/?utm_source=new_course_home_page) for free enrollment.

### **Course 2: Advanced Strands Agents with MCP**
Advanced course focusing on production-ready implementations, advanced tool integration, persistent memory systems, hooks, session management, and enterprise features.

Video Series available [here](https://www.analyticsvidhya.com/courses/advanced-strands-agents-mcp/) for free enrollment.

### **Course 3: Building Multi-Agent Systems**
Develop intelligent multi-agent systems that coordinate, communicate, and solve complex problems using swarm, graph-based and agents as tools patterns with Strands Agents.

Video Series available [here](https://www.analyticsvidhya.com/courses/building-multi-agent-systems-with-strands-agents/) for free enrollment.

### **Course 4: Production Deployment with Amazon Bedrock AgentCore**
Production deployment course covering best practices for running agents in production environments using Amazon Bedrock AgentCore Runtime for serverless scaling and management.

**Total Learning Time**: ~5-6 hours across all courses

---

## 🎓 Course 1: Getting Started with Strands Agents

**Location**: `course-1/` directory

Learn the complete journey of AI agent development, from basic usage to advanced topics like [agent-to-agent (A2A)](https://strandsagents.com/latest/documentation/docs/user-guide/concepts/multi-agent/agent-to-agent/) communication and [observability](https://strandsagents.com/latest/documentation/docs/user-guide/observability-evaluation/observability/).

### What You'll Learn
- Strands Agents Framework - Build intelligent AI agents
- Model Context Protocol (MCP) - Enable tool integration
- Agent-to-Agent Communication - Create multi-agent systems
- Observability & Evaluation - Monitor and improve agent performance

### Course 1 Structure

| 🧪 Lab | 📝 What You'll Learn | ⏱️ Time | 📊 Level |
|--------|---------------------|---------|----------|
| [Lab 1: Strands Agent Basics](course-1/Lab1/) | Agent initialization, system prompts, HTTP tools | 15 min |  |
| [Lab 2: Model Providers](course-1/Lab2/) | Anthropic & Amazon Bedrock integration | 18 min |  |
| [Lab 3: AWS Service Integration](course-1/Lab3/) | AWS service tool usage (S3, DynamoDB) | 15 min |  |
| [Lab 4: MCP & Tools](course-1/Lab4/) | Model Context Protocol, tool creation | 14 min |  |
| [Lab 5: A2A Communication](course-1/Lab5/) | Multi-agent systems & communication | 11 min |  |
| [Lab 6: Observability](course-1/Lab6/) | LangFuse, RAGAS, performance monitoring | 21 min |  |

### Course 1 Lab Details

#### Lab 1: Strands Agent Basics
**Files**: `basic-use.py`, `http-tool-use.py`, `system-prompt-use.py`

Learn the fundamentals of creating and using Strands agents:
- Basic agent initialization and usage
- System prompt customization
- HTTP tool integration

#### Lab 2: Model Providers
**Files**: `anthropic-model-provider.py`, `anthropic-pet-breed-agent.py`, `bedrock-default-config.py`, `bedrock-detailed-config.py`

Explore different model providers and configuration options:
- Anthropic Claude model integration
- Amazon Bedrock model configuration

> **Note**: Some portions of this lab require a pre-existing AWS account for the 'generate_image' tool.

#### Lab 3: AWS Service Integration
**Files**: `aws-tool-use.py`

Learn to integrate AWS services with your Strands agents:
- Using the [`use_aws`](https://github.com/strands-agents/tools/blob/main/src/strands_tools/use_aws.py) tool
- Examples with Amazon S3 and Amazon DynamoDB

> **Note**: The code in this lab requires a pre-existing AWS account to properly utilize the 'use_aws' tool. An example Amazon DynamoDB Table is used to generate results when querying a table.

#### Lab 4: Model Context Protocol (MCP)
**Files**: `mcp-and-tools.ipynb`, `mcp_calulator.py`

Deep dive into the Model Context Protocol:
- MCP server creation
- Tool definition and usage
- Calculator and Weather agents examples
- Interactive Jupyter notebook tutorial

#### Lab 5: Agent-to-Agent Communication
**Files**: `a2a-communication.ipynb`, `run_a2a_system.py`, `employee_data.py`, `employee-agent.py`, `hr-agent.py`

Build multi-agent systems with inter-agent communication:
- A2A communication patterns
- Employee/HR agent system example
- MCP server for data sharing
- REST API integration

#### Lab 6: Observability & Evaluation
**Files**: `observability-with-langfuse-and-evaluation-with-ragas.ipynb`, `restaurant-data/`

Monitor and evaluate agent performance:
- Restaurant recommendation agent example
- LangFuse integration for observability
- RAGAS evaluation framework
- Performance metrics and tracing

---

## 🚀 Course 2: Advanced Strands Agents with MCP

**Location**: `course-2/` directory

A comprehensive advanced course for building production-ready AI agents using the Strands Agents SDK. This repository contains 6 progressive labs that teach advanced capabilities including tool integration, memory persistence, Model Context Protocol (MCP), and comprehensive observability.

### What You'll Learn
- **Strands Agents SDK** - Advanced agent architecture and lifecycle management
- **Model Context Protocol (MCP)** - Standardized tool and service integration  
- **Multi-Provider Configuration** - Amazon Bedrock, Anthropic, OpenAI, and Ollama
- **Advanced Processing** - Hooks, session management, and conversation strategies
- **Memory Systems** - Long-term persistent memory with FAISS, OpenSearch, and Mem0
- **Enterprise Features** - Observability, metrics analysis, and performance optimization

### Course 2 Structure

| 🧪 Lab | 📝 What You'll Learn | ⏱️ Time | 📊 Level |
|--------|---------------------|---------|----------|
| [Lab 1: Overview of Strands Agents](course-2/Lab1/) | Fundamental agentic AI concepts, agent lifecycle | 13 min |  |
| [Lab 2: Model Providers](course-2/Lab2/) | Multi-provider configuration, metrics analysis | 12 min |  |
| [Lab 3: Advanced Response Processing](course-2/Lab3/) | Hooks, lifecycle management, async patterns | 14 min |  |
| [Lab 4: Tools & MCP Integration](course-2/Lab4/) | Custom tools, MCP servers, self-extending agents | 19 min |  |
| [Lab 5: Session Management](course-2/Lab5/) | Conversation strategies, state persistence | 11 min |  |
| [Lab 6: Memory Persistent Agents](course-2/Lab6/) | Long-term memory, FAISS, OpenSearch, Mem0 | 15 min |  |

### Course 2 Lab Details

#### Lab 1: Overview of Strands Agents (12:52)
**Files**: `first_agent.py`

Learn fundamental agentic AI concepts and build your first Strands agent:
- Basic agent creation with default configuration (no API keys required)
- Core agent components and execution flow
- Agent result examination (message, metrics, state, stop reasons)
- Dynamic model configuration and system prompt modification
- Conversation history management and message clearing

#### Lab 2: Model Providers and Configuration (11:59)
**Files**: `anthropic_model.py`, `bedrock_model.py`, `ollama_model.py`, `openai_model.py`

Configure agents across multiple LLM providers for flexibility and cost optimization:
- Model architecture overview and provider-specific parameters
- Bedrock model setup with structured output capabilities
- Anthropic model configuration with thinking mode
- Ollama local deployment and OpenAI integration
- Metrics analysis and performance monitoring

#### Lab 3: Advanced Response Processing with Hooks (13:30)
**Files**: `async_example.py`, `hook_example_1.py`, `hook_example_2.py`

Implement custom logic to intercept and modify agent behavior at lifecycle points:
- Event-driven hook system and lifecycle management
- Before/after event handling and agent modifications
- Async iterators, callback handlers, and retry logic
- Tool hook examples and precision parameter setup

#### Lab 4: Tools and MCP Integration (18:55)
**Files**: `mcp_integration.py`, `self_extending_example.py`, `tools/`

Extend agent capabilities with custom tools and external service integration:
- Built-in tools from strands-agents-tools library
- Custom tool creation using @tool decorator
- MCP server configuration for AWS Documentation and Pricing
- Self-extending agents and meta tooling capabilities
- Proper error handling and security implementation

#### Lab 5: Conversation and Session Management (11:26)
**Files**: `session_example.py`, `verify_session.py`

Manage conversation state and context effectively across interactions:
- Context window challenges and management strategies
- Three conversation manager approaches (Null, SlidingWindow, Summarizing)
- Session state persistence and user isolation
- File-based and Amazon S3 session storage options

#### Lab 6: Memory Persistent Agents (15:19)
**Files**: `memory_example.py`

Build agents with long-term memory capabilities across conversations:
- Memory backends integration (FAISS, OpenSearch, Mem0)
- Web search integration with DuckDuckGo
- Memory storage, retrieval, and relevance scoring
- Amazon Bedrock Knowledge Bases integration
- Retention policies and privacy controls

---

## 🤖 Course 3: Building Multi-Agent Systems

**Location**: [Strands Samples](https://github.com/strands-agents/samples/tree/main/01-tutorials/02-multi-agent-systems) 

Develop intelligent multi-agent systems that coordinate, communicate, and solve complex problems using swarm, graph-based and agents as tools patterns with Strands Agents.

### Course 3 Structure

| 🧪 Lab | 📝 What You'll Learn | ⏱️ Time | 📊 Level |
|--------|---------------------|---------|----------|
| [Lab 1: Multi-Agent Systems with Swarm Intelligence](https://github.com/strands-agents/samples/blob/main/01-tutorials/02-multi-agent-systems/02-swarm-agent/swarm.ipynb) | Use a Jupyter notebook to deep dive into the Swarm multi-agent pattern | 30 min |  |
| [Lab 2: Multi-Agent Systems with Agent Graph](https://github.com/strands-agents/samples/blob/main/01-tutorials/02-multi-agent-systems/03-graph-agent/graph.ipynb) | Use a Jupyter notebook to deep dive into the Graph multi-agent pattern | 25 min |  |
| [Lab 3: Multi-Agent System with Agents as a Tools](https://github.com/strands-agents/samples/blob/main/01-tutorials/02-multi-agent-systems/01-agent-as-tool/agent-as-tools.ipynb) | Use a Jupyter notebook to deep dive into the Agents as Tools multi-agent pattern | 20 min |  |

---

## 🚀 Course 4: Production Deployment with Amazon Bedrock AgentCore

**Location**: `course-4/` directory

Learn to deploy production-ready AI agents using Amazon Bedrock AgentCore Runtime. This course focuses on serverless deployment, scaling, and management of agents in production environments.

### What You'll Learn
- **Production Best Practices** - Understand differences between development and production agent deployment
- **Amazon Bedrock AgentCore** - Comprehensive overview of AgentCore services and components
- **Serverless Deployment** - Deploy agents with auto-scaling and session management
- **Production Operations** - Monitor, troubleshoot, and maintain production agent systems

### Course 4 Structure

| 🧪 Lab | 📝 What You'll Learn | ⏱️ Time | 📊 Level |
|--------|---------------------|---------|----------|
| [Lab 1: Operating Agents in Production](course-4/) | Production best practices, development vs production differences | 9 min |  |
| [Lab 2: Introduction to Amazon Bedrock AgentCore](course-4/) | Amazon Bedrock AgentCore fundamentals, service component overview | 12 min |  |
| [Lab 3: Building agents with Amazon Bedrock AgentCore](course-4/) | Hands-on deployment with AgentCore Runtime | 20 min |  |

### Course 4 Lab Details

#### Lab 1: Operating Agents in Production (9:00)
Understand the best practices for running agents in a production setting and how that differs from local development.

#### Lab 2: Introduction to Amazon Bedrock AgentCore (12:00)
Understand the fundamentals of Amazon Bedrock AgentCore and its components.

#### Lab 3: Building a Calculator Agent (20:00)
**Files**: `my_agent.py`, `invoke_agent.py`, `requirements.txt`

Hands-on deployment of a production-ready calculator agent:
- Agent creation with Strands Agents framework
- AgentCore Runtime deployment and configuration
- Testing deployed agents with session management
- Production invocation patterns and best practices

> **Note**: This lab requires an AWS account with appropriate permissions and model access enabled in Amazon Bedrock console.

---

## 🛠️ Technologies & Services

| 🔧 Technology | 🎯 Purpose | 📖 Documentation |
|--------------|-----------|-----------------|
| **Strands Agents** | AI agent framework | [Docs](https://strandsagents.com/) |
| **Anthropic Claude** | Alternative LLM provider | [Docs](https://docs.anthropic.com/) |
| **Amazon Bedrock** | AWS managed LLM service | [Docs](https://docs.aws.amazon.com/bedrock/) |
| **OpenAI** | Alternative LLM provider | [Docs](https://platform.openai.com/docs) |
| **Ollama** | Local model deployment | [Docs](https://ollama.ai/) |
| **Model Context Protocol** | Tool integration standard | [Docs](https://modelcontextprotocol.io/) |
| **LangFuse** | Observability & tracing | [Docs](https://langfuse.com/docs) |
| **RAGAS** | Agent evaluation | [Docs](https://docs.ragas.io/) |
| **Mem0** | Memory persistence | [Docs](https://docs.mem0.ai/) |
| **FAISS** | Vector similarity search | [Docs](https://github.com/facebookresearch/faiss) |
| **OpenSearch** | Search and analytics | [Docs](https://opensearch.org/docs/) |

---

## 📋 Prerequisites

### Course 1 Requirements
- **Python 3.10+**
- **Virtual environment** (recommended)
- **API keys for at least one of:**
  - Anthropic Claude 
  - Amazon Bedrock
- **For Lab 6:** LangFuse account and API key
- **For Labs 3, 5:** AWS account with appropriate CLI configuration

### Course 2 Requirements
- **Completion of Course 1** (Labs 1-6) or equivalent knowledge
- **Python 3.10+**
- **Virtual environment** (recommended)
- **Anthropic Claude API key** (primary requirement) - Get from [Anthropic Console](https://console.anthropic.com/)
- **Additional API keys for specific labs:**
  - Amazon Bedrock (for AWS integration labs)
  - OpenAI (optional alternative)
  - Mem0 (for Lab 6 memory persistence)

### Course 3 Requirements
- **Completion of Course 1-2** (Labs 1-6) or equivalent knowledge
- **Python 3.10+**
- **Virtual environment** (recommended)
- **AWS account with Anthropic Claude 3.7 enabled on Amazon Bedrock**
- **AWS IAM role with permissions to use Amazon Bedrock**

### Course 4 Requirements
- **Completion of Course 1-3** or equivalent knowledge
- **AWS Account** with appropriate permissions
- **Python 3.10+**
- **AWS CLI configured** with `aws configure`
- **AWS Permissions**: [BedrockAgentCoreFullAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/BedrockAgentCoreFullAccess.html) policy
- **Model Access**: Anthropic Claude 3.5 Haiku enabled in Amazon Bedrock console

---

## 🚀 Getting Started

### 1. Clone the Repository

```bash
git clone https://github.com/aws-samples/sam

…

## Source & license

This open-source MCP server is cataloged on AgentStack and links to its original source — we do not rehost the code.

- **Author:** [aws-samples](https://github.com/aws-samples)
- **Source:** [aws-samples/sample-getting-started-with-strands-agents-course](https://github.com/aws-samples/sample-getting-started-with-strands-agents-course)
- **License:** MIT-0

Install and usage instructions live in the source repository linked above.

## Pricing

- **Free** — Free

## Security capabilities

Automated source analysis of v0.1.0 — what this tool can access:

- **Network access:** no
- **Filesystem access:** no
- **Shell / process execution:** no
- **Environment & secrets:** yes
- **Dynamic code execution:** no

*"Yes" means the capability is present in the source — more access means more to trust, not that it is unsafe.*


## Versions

- **0.1.0** — security scan: passed — Imported from the upstream source.

## Links

- Listing page: https://agentstack.voostack.com/l/mcp-aws-samples-sample-getting-started-with-strands-agents-course
- Seller: https://agentstack.voostack.com/s/aws-samples
- Browse the marketplace: https://agentstack.voostack.com/browse

---
Listed on AgentStack — the marketplace for AI agent skills and MCP servers. Every listing is security-reviewed. Creators keep 70%.