Weekend Creative Challenge :xenocurator
AI-powered multimodal app using Amazon Bedrock, Nova, Strands, MCP, Podman, GitHub Actions, and AWS Lightsail for production-ready agentic AI.
From Multimodal AI to Production: Building an Agentic Application with Amazon Bedrock, Strands, MCP, and AWS Lightsail
Building an AI application is more than connecting a foundation model to an API. A production-ready system needs an inference layer, an agent orchestration layer, reliable infrastructure, containerization, CI/CD, and a deployment environment that can run the entire stack consistently.
In this project, I built an AI-powered application using Amazon Bedrock, the Amazon Nova model family, Strands Agents SDK, and Model Context Protocol (MCP). The application is containerized using Podman, continuously built through GitHub Actions, and deployed to AWS Lightsail.
The goal was to create a practical architecture where the AI layer could process multimodal inputs, use tools through an agentic workflow, and eventually run as a production service rather than remaining a local prototype.
Architecture at a Glance
The application follows a relatively simple deployment flow:
User → Application Backend → Strands Agent → MCP Tools → Amazon Bedrock → Amazon Nova
The infrastructure pipeline follows:
Git Push → GitHub Actions → Container Build → Container Image → AWS Lightsail → Production Application
This separation helped keep application logic, AI orchestration, and deployment concerns independent.
1. Amazon Bedrock as the AI Inference Layer
At the core of the application is Amazon Bedrock, which provides access to foundation models through managed AWS APIs.
The application uses models from the Amazon Nova family, including models such as Nova Lite and Nova Micro, depending on the inference requirement.
One important advantage of this architecture is that the application does not need to manage model servers, GPU infrastructure, model downloads, or inference runtimes itself.
Instead, the backend communicates with the Bedrock Runtime API and sends the required prompt and multimodal inputs.
For image-oriented workloads, this allows the application to pass visual information to a multimodal model and receive structured reasoning or analysis from the model.
The architecture therefore becomes:
Application | vAWS SDK / Boto3 | vAmazon Bedrock Runtime | vAmazon Nova | vInference Result
This keeps the model infrastructure outside the application while allowing the application to focus on orchestration and business logic.
2. Boto3 for AWS Integration
The Python backend uses Boto3, the AWS SDK for Python, as the programmatic interface to AWS services.
Boto3 is responsible for establishing AWS sessions and communicating with the Bedrock Runtime service.
The client configuration also provides control over operational behavior such as:
- Request timeouts
- Retry configuration
- Adaptive retry behavior
- AWS region configuration
- Runtime API communication
This becomes particularly important when moving from a local development environment to a deployed application.
Instead of treating the model API as a simple HTTP request, the application treats it as part of an AWS-managed production service with appropriate client configuration and failure handling.
3. Strands Agents SDK for Agentic Orchestration
Calling an LLM directly is only one part of an AI application.
The more interesting layer is deciding what the model should do, what tools it can access, and what context should be passed between different operations.
For this, the application uses the Strands Agents SDK.
Strands provides the agentic orchestration layer between the application and the underlying foundation model.
Conceptually:
Application Request | v Strands Agent | +----> Prompt / Context | +----> Tool Selection | +----> MCP Integration | v Bedrock Model | v Agent Response
This architecture makes the foundation model part of a larger execution loop rather than treating it as an isolated text-generation endpoint.
The agent can reason over the available context, determine which capabilities are required, invoke tools, and use the resulting information as part of the overall workflow.
4. MCP for Tool Integration
The project also integrates Model Context Protocol (MCP) into the agent architecture.
MCP provides a standardized way for models and agents to interact with external tools and contextual capabilities.
Instead of tightly coupling every tool directly into the core application logic, MCP can act as an interface between the agent and the capabilities it needs.
This gives the architecture a useful separation:
┌──────────────────┐ │ Application │ └────────┬─────────┘ | v ┌──────────────────┐ │ Strands Agent │ └────────┬─────────┘ | v ┌──────────────────┐ │ MCP Client │ └────────┬─────────┘ | ┌────────┴─────────┐ | | v v Tool / Data Tool / Service | v Amazon Bedrock
This separation is particularly useful when building agentic systems because tools can evolve independently from the model layer.
5. Containerizing the Application with Podman
Once the application logic was ready, the next challenge was making the runtime reproducible.
The application is containerized using Podman.
Podman provides a daemonless container engine and supports OCI-compatible container images. This makes it possible to build and run the application in a standardized environment without depending on a Docker daemon.
The container packages the application runtime and its dependencies so that the same application artifact can move through development and deployment environments.
The flow becomes:
Source Code | vContainerfile | vPodman Build | vOCI Container Image
This also reduces the difference between local development and production deployment.
6. GitHub Actions as the CI/CD Layer
After containerization, the next requirement was automation.
Instead of manually rebuilding and deploying the application after every change, GitHub Actions is used as the CI/CD layer.
A typical pipeline looks like:
Developer Push | vGitHub Repository | vGitHub Actions | +----> Validate / Test | +----> Build Container | +----> Push Artifact | vDeployment Pipeline
This gives every code change a repeatable path toward deployment.
It also creates a clean separation between development and infrastructure operations: developers push code, while the pipeline performs the repeatable build and delivery steps.
7. Deploying the Container to AWS Lightsail
For production hosting, the containerized application runs on AWS Lightsail.
Lightsail provides a relatively straightforward way to deploy an application without managing a large Kubernetes or ECS-based infrastructure stack.
The deployment architecture is:
GitHub | | Push vGitHub Actions | | Build vOCI Container Image | | Deploy vAWS Lightsail | vProduction Backend | vAmazon Bedrock
The backend is exposed through the public web while maintaining the necessary AWS permissions to communicate with Amazon Bedrock.
This creates a compact production architecture suitable for an application that needs a persistent backend but does not require a large orchestration platform.
8. IAM and AWS Security
One of the important differences between a local prototype and a production deployment is how AWS credentials are handled.
The deployed application needs permission to invoke the required Bedrock APIs, but the application should not simply embed long-lived AWS access keys inside source code or container images.
Instead, the production environment should use appropriate AWS identity and access mechanisms so that the runtime receives only the permissions it requires.
The principle is straightforward:
Give the application permission to perform its required AWS operations — and nothing more.
This is especially important for AI applications because model invocation can become a significant cloud resource operation.
9. Why This Architecture?
The architecture intentionally avoids putting everything into a single monolithic layer.
Each component has a specific responsibility:
Layer | Technology | Responsibility |
|---|---|---|
AI inference | Amazon Bedrock | Foundation model inference |
Model family | Amazon Nova | Multimodal AI capabilities |
AWS SDK | Boto3 | AWS service communication |
Agent layer | Strands Agents SDK | Agent orchestration |
Tool protocol | MCP | Tool/context integration |
Container runtime | Podman | OCI containerization |
CI/CD | GitHub Actions | Automated build and delivery |
Production | AWS Lightsail | Application hosting |
This makes the architecture easier to reason about and gives each layer a clear boundary.
10. From Prototype to Production
The biggest lesson from this project was that building an AI application is not simply a matter of selecting a powerful model.
A production AI system needs multiple layers working together:
Model → SDK → Agent → Tools → Application → Container → CI/CD → Cloud
Amazon Bedrock removes much of the complexity around model infrastructure. Strands provides an agentic abstraction for coordinating model interactions and tools. MCP provides a standardized mechanism for connecting capabilities to the agent. Podman packages the application into a reproducible runtime, while GitHub Actions automates the delivery process. Finally, AWS Lightsail provides a practical production environment for running the containerized service.
The result is a compact but extensible architecture for deploying an AI application from source code to a publicly accessible production service.
What I Learned
Working across the complete stack highlighted an important principle:
AI engineering is increasingly becoming systems engineering.
The model is only one component.
The real engineering challenge is building the surrounding system that can reliably provide context, invoke tools, handle failures, manage infrastructure, control permissions, package dependencies, and continuously deliver new versions.
This project gave me hands-on experience across that entire path — from multimodal inference with Amazon Bedrock and Nova, to agent orchestration with Strands and MCP, to containerization, CI/CD, and cloud deployment with AWS Lightsail.
And that is ultimately what makes an AI prototype evolve into an actual application.



Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article