Nova Month Amazon Nova + Strands Agents, Nova Month

This document explains the 5 progressive challenges for the Amazon Nova + Strands Agents skill sprint, demonstrating how to build increasingly sophisticated AI agents.

Aadi Basal

Published Jun 13, 2026

Last modified Jun 13, 2026

Challenge 1: First Agent 🤖

File: April-2026/challenge-1-first-agent/starter.py

What It Does:

Introduces the fundamentals of creating an AI agent using the Strands Agents SDK
Uses OllamaModel to run a local LLM (llama3.2:3b) for 100% offline capability
Agent responds to a simple prompt about Python
Demonstrates graceful fallback: if Ollama isn't available, returns a hardcoded fun fact

Key Concepts:

Agent initialization and setup
Model configuration (local Ollama vs cloud-based)
Basic agent response handling

Output:

1
"Python is a high-level programming language created by Guido van Rossum..."

Challenge 2: Tools 🔧

File: April-2026/challenge-2-tools/starter.py

What It Does:

Expands Challenge 1 by adding custom tools the agent can use
Implements three tools:
1. Calculator (built-in strands-tools): Performs arithmetic
2. Weather Tool: Queries weather API for a city (wttr.in) with fallback
3. Age Calculator: Parses birthdates and calculates age
Agent can intelligently choose which tool to use based on the user's request
Uses Amazon Bedrock Nova Pro model (more capable than Ollama)

Key Concepts:

Tool definition and registration
Tool selection by the agent
API integration (weather)
Graceful fallbacks when dependencies aren't available

Output Example:

1
2
3
Math Problem: 714
Weather in Chennai: sunny, 28°C (fallback)
Age from 1998-06-15: 26 years

Challenge 3: Memory 🧠

File: April-2026/challenge-3-memory/starter.py

What It Does:

Builds on Challenge 2 by adding persistent memory using FAISS vector database
Agent can now remember facts told to it and recall them in future conversations
Uses mem0_memory tool from strands-tools with fallback to local in-memory storage
Demonstrates memory across multiple interactions

Key Concepts:

Vector embeddings for semantic memory
Persistent storage (FAISS local files)
Memory retrieval and querying
Session continuity

Demo Sequence:

User: "Remember my name is Ravi and I love biryani"
Agent: Stores in memory
User: "What's my name?"
Agent: Recalls from memory → "Your name is Ravi"
Shows memory persistence across interactions

Output:

1
2
3
Memory stored: name=Ravi, preference=biryani
Recall query: "What's my name?" 
Response: "Your name is Ravi and you love biryani"

Challenge 4: Full Agent ⚡

File: April-2026/challenge-4-full-agent/starter.py

What It Does:

Combines all previous elements: tools + memory + streaming
Adds real-time streaming callbacks to show agent thinking
Demonstrates multi-step agent interactions:
- Remember personal information
- Recall from memory
- Query external data (weather)
- Perform calculations
- Use memory across multiple requests

Key Concepts:

Streaming responses (agent shows "thinking" in real-time)
Tool usage indicators ("🔧 Using tool: calculator")
Complex multi-step workflows
Full agent lifecycle

Demo Sequence:

1
2
3
4
5
1. Remember: "My name is Ravi"
2. Recall: "What's my name?" → Uses memory
3. Weather: "What's weather in Chennai?" → Uses weather tool
4. Calculation: "What's 17 × 42?" → Uses calculator
5. Cross-reference: Recalls name while answering complex query

Output:

1
2
3
4
5
6
7
8
9
10
🔧 Using tool: mem0_memory
Remembering: Ravi's preference...

🔧 Using tool: weather
Weather in Chennai: 28°C, sunny

🔧 Using tool: calculator  
17 × 42 = 714

And your name is Ravi!

Challenge 5: Architecture-to-Diagram Bot 🏗️

File: April-2026/challenge-5-innovate-mcp-chatbot/starter.py

What It Does:
This challenge is a creative innovation task where you design your own agent use case. The implementation is an Architecture-to-Diagram Bot that converts natural language architecture descriptions into Mermaid diagrams.

Core Functionality

1. Architecture Parsing (generate_mermaid function)

Accepts natural language descriptions of system architectures
Recognizes AWS components:
- Services: Lambda, API Gateway, DynamoDB, S3, RDS, CloudFront, SQS, SNS
- Infrastructure: VPC, Load Balancer, IAM, CloudWatch
- Data: Database, Cache, Queue, Stream
Generates Mermaid flowchart (left-to-right format)
Creates boxes with proper connections showing data flow

Example Input:

1
2
"serverless web app with Lambda processing events from API Gateway, 
storing data in DynamoDB, and serving static assets from S3"

Generated Mermaid Diagram:

1
2
3
4
5
6
7
8
9
flowchart LR
    API[API Gateway]
    Lambda[AWS Lambda]
    DDB[DynamoDB]
    S3[S3 Bucket]
    
    API --> Lambda
    Lambda --> DDB
    Lambda --> S3

2. Diagram Persistence (save_mermaid function)

Saves generated Mermaid diagrams to output/ folder
Creates files like output/architecture_demo.mmd
Can be rendered on GitHub, GitLab, or Mermaid Live Editor

3. MCP Integration (try_create_aws_docs_mcp function)

Attempts to instantiate an AWS Documentation MCP (Model Context Protocol) server
Provides enhanced AWS service descriptions if available
Gracefully falls back if MCP is unavailable

Why This Challenge Matters

Real-World Application:

Helps architects and engineers communicate system designs in code-friendly format
Bridges the gap between Markdown documentation and visual diagrams
Useful for design reviews, documentation, and Infrastructure-as-Code workflows

Agent Capabilities Demonstrated:

Natural language understanding: Parse complex architecture descriptions
Domain knowledge: Recognize AWS services and their relationships
Code generation: Output valid Mermaid syntax
File I/O: Persist diagrams for reuse
Extensibility: Optional MCP for enhanced capabilities

Architecture Bot Features

Mode 1: Demo Mode (DEMO=1)

1
DEMO=1 python3 starter.py

Runs pre-configured examples:

Simple serverless app
Microservices architecture
Data pipeline with multiple stages

Mode 2: Interactive Mode

1
python3 starter.py

Prompts user to:

Enter architecture description
Generate and save Mermaid diagram
Ask for follow-up refinements

Example Architectures Supported

1. Serverless Web App:

1
2
Input: "API Gateway → Lambda → DynamoDB + S3"
Output: Flowchart showing API handling, Lambda processing, dual storage

2. Microservices with Messaging:

1
2
Input: "Multiple services publishing events to SNS, consumed by SQS workers"
Output: Pub-sub architecture diagram with message routing

3. Data Processing Pipeline:

1
2
Input: "S3 data ingestion → Lambda processing → DynamoDB storage → CloudFront delivery"
Output: ETL pipeline with data flow visualization

Fallback & Offline Support

Works completely offline (no AWS credentials needed)
Graceful degradation if MCP unavailable
Heuristic-based parsing ensures basic functionality always works
All output saved locally in output/ folder

Key Technologies Across All Challenges

Technology	Purpose	Challenges
Strands Agents SDK	Core agent framework	All
OllamaModel	Local LLM inference	1
Amazon Bedrock Nova Pro	Cloud LLM	2-5
strands-tools	Pre-built tools (calculator, mem0)	2-5
FAISS	Vector database for memory	3-5
wttr.in API	Weather data	2-5
Mermaid	Diagram rendering	5
MCP (Model Context Protocol)	Optional: AWS documentation server	5

Progression Summary

1
2
3
4
5
6
7
8
9
Challenge 1: Agent Creation (offline)
    ↓
Challenge 2: + Tools Integration (cloud model)
    ↓
Challenge 3: + Persistent Memory
    ↓
Challenge 4: + Streaming & Multi-step Workflows
    ↓
Challenge 5: + Custom Innovation (Architecture Bot)

Each builds upon the previous, introducing new concepts while maintaining backward compatibility with offline fallbacks.

Running All Challenges

1
2
3
4
5
6
7
8
9
10
# Challenge 1: Basic agent
python3 April-2026/challenge-1-first-agent/starter.py

# Challenge 2: Tools
python3 April-2026/challenge-2-tools/starter.py

# Challenges 3-5 with DEMO mode (no interaction needed)
DEMO=1 python3 April-2026/challenge-3-memory/starter.py
DEMO=1 python3 April-2026/challenge-4-full-agent/starter.py
DEMO=1 python3 April-2026/challenge-5-innovate-mcp-chatbot/starter.py

Challenge 5: Architecture-to-Diagram Bot - Deep Dive

The 5th challenge showcases creative AI agent application by solving a real problem: converting informal architecture descriptions into formal diagrams. This bot demonstrates:

✅ NLP Understanding: Parse natural language architecture specs
✅ Domain Expertise: Recognize AWS services and their interactions
✅ Code Generation: Produce valid Mermaid syntax
✅ Persistence: Save diagrams for documentation
✅ Extensibility: Optional MCP for enhanced AWS knowledge
✅ Resilience: Works offline with graceful degradation

This makes it valuable for:

Architecture review documentation
Infrastructure-as-Code comments
Design decision tracking
Team collaboration on system designsCheck it out here at : https://github.com/aadi-basal-06/builders-skill-sprint-challenges/tree/main/April-2026

# aws-mcp-server # generative-ai # strands-agents

Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.

Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article

Builder Center

Nova Month Amazon Nova + Strands Agents, Nova Month

Aadi Basal

Challenge 1: First Agent 🤖

Challenge 2: Tools 🔧

Challenge 3: Memory 🧠

Challenge 4: Full Agent ⚡

Challenge 5: Architecture-to-Diagram Bot 🏗️

Core Functionality

Why This Challenge Matters

Architecture Bot Features

Example Architectures Supported

Fallback & Offline Support

Key Technologies Across All Challenges

Progression Summary

Running All Challenges

Challenge 5: Architecture-to-Diagram Bot - Deep Dive