Agent AI
As part of the AWS Builders Skill Sprint, I built a series of AI agents using Strands SDK and Ollama (llama3.2:3b). Starting with a basic conversational agent, I progressively added tool calling, persistent memory using Mem0 and FAISS, and MCP integration. This project helped me gain hands-on experience with agentic AI concepts such as reasoning, tool usage, memory management, and extensible AI architectures.
Building AI Agents with Strands SDK and Ollama: My AWS Builders Skill Sprint Journey
Introduction
As part of the AWS Builders Skill Sprint, I explored how to build AI agents using the Strands SDK and locally hosted Large Language Models through Ollama.
The goal was not only to create a chatbot but also to understand how modern AI agents are built incrementally using:
- Large Language Models (LLMs)
- Tool Calling
- Persistent Memory
- Vector Databases
- MCP (Model Context Protocol)
Across five challenges, I developed increasingly capable agents that evolved from a simple conversational assistant into a memory-enabled and tool-augmented AI system.
Challenge 1: Basic AI Agent
Objective
Create a simple AI agent using:
- Strands SDK
- Ollama
- llama3.2:3b model
What I Built
A basic conversational AI agent capable of interacting with users through a command-line interface.
Features
- Local LLM execution
- Interactive chat loop
- No external API dependency
- Beginner-friendly architecture
Learning Outcomes
Through this challenge, I learned:
- How Strands SDK initializes an agent
- How Ollama serves local language models
- How prompts are sent and responses are generated
- Basic conversational AI workflows
Challenge 2: Tools Agent
Objective
Extend the basic agent by adding external tools.
Implemented Tools
Calculator Tool
Performs mathematical operations such as:
- Addition
- Subtraction
- Multiplication
- Division
Weather Tool
Provides weather-related responses.
Age Calculator Tool
Calculates age based on birth year information.
What I Learned
This challenge introduced the concept of Tool Calling.
Instead of relying solely on the language model, the agent can:
- Identify a user request
- Select the correct tool
- Execute the tool
- Return the result
This is one of the fundamental capabilities of modern AI agents.
Challenge 3: Memory Agent
Objective
Add persistent memory capabilities to the agent.
Technologies Used
- Mem0
- FAISS
- Ollama
- Strands SDK
Features
Persistent User Memory
The agent remembers user information across conversations.
Example:
User:
"My name is Thamarai"
"My name is Thamarai"
Agent:
"Nice to meet you, Thamarai."
"Nice to meet you, Thamarai."
Later:
User:
"What is my name?"
"What is my name?"
Agent:
"Your name is Thamarai."
"Your name is Thamarai."
Memory Storage
User information is stored in a vector database using FAISS.
Retrieval Mechanism
Relevant memories are retrieved and supplied as context to the LLM.
Key Learning
This challenge helped me understand:
- Memory architecture in AI agents
- Vector embeddings
- Similarity search
- Long-term conversational context
Challenge 4: Full Agent
Objective
Combine all previous capabilities into a single AI agent.
Features
Tool Integration
- Calculator
- Weather Tool
- Age Calculator
Persistent Memory
- Mem0
- FAISS
Interactive Conversations
The agent supports continuous multi-turn interactions.
User Recall
Stored information can be retrieved and reused in future conversations.
Architecture Overview
User Input
↓
Strands Agent
↓
LLM (Ollama)
↓
Tool Selection
↓
Memory Retrieval
↓
Final Response
↓
Strands Agent
↓
LLM (Ollama)
↓
Tool Selection
↓
Memory Retrieval
↓
Final Response
Key Learning
This challenge demonstrated how modern AI assistants combine:
- Reasoning
- Tool Usage
- Memory
- Conversational Context
into a unified system.
Challenge 5: MCP Chatbot
Objective
Build an AI agent capable of interacting with MCP servers.
What is MCP?
MCP (Model Context Protocol) provides a standardized way for AI agents to connect to external tools and services.
It acts as a bridge between:
- AI Models
- Tools
- Data Sources
- External Applications
Features Implemented
MCP Tool Access
The agent can invoke tools exposed through an MCP server.
Interactive Chatbot
Users can communicate naturally while the agent utilizes MCP resources when needed.
Extensible Design
Additional MCP tools can be added without redesigning the entire agent.
Key Learning
This challenge introduced:
- MCP architecture
- Tool discovery
- Tool execution workflows
- Agent extensibility patterns
These concepts are increasingly important in modern AI ecosystems.
Overall Learning Outcomes
By completing all five challenges, I gained hands-on experience with:
AI Agent Fundamentals
- Agent design
- Prompt orchestration
- Conversational systems
Local LLM Deployment
- Ollama setup
- Running llama3.2:3b locally
Tool Calling
- Calculator tools
- Utility tools
- External integrations
Memory Systems
- Mem0
- FAISS
- Persistent context
MCP Integration
- Protocol-based tool access
- Agent extensibility
Conclusion
The AWS Builders Skill Sprint provided an excellent practical introduction to AI Agent development.
Starting with a simple conversational agent and progressively adding tools, memory, and MCP integration allowed me to understand how production-grade AI systems are structured.
These challenges demonstrated that modern AI agents are much more than language models. They combine reasoning, memory, tool usage, and external integrations to solve real-world problems effectively.
I look forward to extending these projects further by integrating cloud services, advanced memory architectures, and enterprise-grade MCP tool ecosystems.
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article