DEV Community: Ujjwal B Soni

Running AWS Strands Decider 2B Locally: A Complete Setup Guide for AI Routing & Multi-RAG Systems

Ujjwal B Soni — Sat, 03 Oct 2026 02:33:20 +0000

🚀 Running AWS Strands Decider 2B Locally for Multi-RAG and Agentic AI Applications

As GenAI applications become more sophisticated, one challenge continues to surface:

How do we make reliable decisions before invoking an LLM?

For example:

Which datasource should answer this question?
Should I query PLM, Jira, or Confluence?
Do I have enough context to answer confidently?
Should an AI agent invoke a tool or ask a clarification question?

Traditionally, we let an LLM make these decisions.

Recently, AWS introduced Strands Decider 2B, a lightweight decision model designed specifically for routing, classification, scoring, and orchestrating agent workflows.

Unlike traditional LLMs, Strands Decider doesn't generate arbitrary text. Instead, it selects from predefined options and provides confidence scores, making it ideal for Agentic AI and Multi-RAG systems.

In this article, I'll walk through how I installed and tested Strands Decider 2B locally on Windows using WSL2.

Why Use a Decision Model?

A common architecture today looks like this:

The problem?

The LLM is responsible for both:

Making decisions
Generating responses

A better approach is:

Now the LLM focuses on reasoning and generation, while the decision model handles routing and orchestration.

Environment

For this walkthrough I used:

Windows 11
WSL2
Ubuntu
Python Virtual Environment
Strands Decider 2B

Step 1: Verify WSL2 Installation

Open PowerShell:

wsl -l -v

Example output:

NAME      STATE    VERSION
Ubuntu    Running  2

Launch Ubuntu:

wsl -d Ubuntu

Step 2: Create a Workspace

mkdir -p /mnt/c/GENAI/strands

cd /mnt/c/GENAI/strands

Step 3: Install Required Packages

Update Ubuntu:

sudo apt update

Install required dependencies:

sudo apt install -y \
 python3 \
 python3-pip \
 python3-venv \
 python3-dev \
 build-essential \
 gcc \
 g++

Step 4: Create a Virtual Environment

Create the environment:

python3 -m venv .venv

Activate it:

source .venv/bin/activate

Upgrade pip:

pip install --upgrade pip setuptools wheel

Step 5: Install Strands Decider

pip install strands-decider

Verify installation:

strands-decider --help

Step 6: Discover Available Models

Install Hugging Face Hub:

pip install huggingface_hub

Authenticate to Hugging Face hub

hf auth login

List available Strands models:

python -c "from huggingface_hub import list_models; [print(m.id) for m in list_models(search='strands')]"

The model used in this guide:

StrandsAgents/strands-decider-2B-hobson-v19

Step 7: Start the Model Server

Launch the model:

strands-decider serve StrandsAgents/strands-decider-2B-hobson-v19 --device cpu

Expected output:

Application startup complete.
Uvicorn running on http://127.0.0.1:8000

The first startup downloads and caches the model automatically.

Step 8: Verify the API

Open in your browser:

http://127.0.0.1:8000/docs

Or:

curl http://127.0.0.1:8000/openapi.json

Understanding Question Types

Strands Decider supports three decision formats.

Choice Question

Choose one option from a list.

{
  "type": "choice",
  "instructions": "Select the best datasource.",
  "criteria": {
    "PLM": "Engineering changes and parts",
    "JIRA": "Issue tracking system",
    "CONFLUENCE": "Documentation repository",
    "UNKNOWN": "No suitable source"
  }
}

Noul Question

Yes / No decision.

{
  "type": "noul",
  "instructions": "Determine whether this statement is true."
}

Score Question

Rate against an ordered scale.

{
  "type": "score",
  "instructions": "Rate the sentiment.",
  "criteria": [
    "Very Negative",
    "Negative",
    "Neutral",
    "Positive",
    "Very Positive"
  ]
}

Testing with Python

Create a file called:

decider_demo.py

import requests
import json

payload = {
    "state": "User wants ECO information",
    "questions": {
        "datasource": {
            "type": "choice",
            "instructions": "Select the most appropriate datasource.",
            "criteria": {
                "PLM": "Engineering changes and parts",
                "JIRA": "Issue tracking system",
                "CONFLUENCE": "Documentation repository",
                "UNKNOWN": "No suitable source"
            }
        }
    }
}

response = requests.post(
    "http://127.0.0.1:8000/v1/systemone",
    json=payload
)

print(json.dumps(response.json(), indent=2))

Run:

python decider_demo.py

Sample output:

{
  "answers": {
    "datasource": {
      "choice": "PLM",
      "confidence": 0.94
    }
  }
}

Using It as a Multi-RAG Router

One use case I was particularly interested in was reducing hallucinations across multiple RAG systems.

Routing logic becomes simple:

decision = response["answers"]["datasource"]["choice"]

if decision == "PLM":
    plm_rag.search(query)

elif decision == "JIRA":
    jira_rag.search(query)

elif decision == "CONFLUENCE":
    confluence_rag.search(query)

else:
    print("No reliable datasource identified.")

Instead of asking an LLM to guess which datasource to use, the decision model handles routing first.

Real-World Enterprise Use Cases

I see strong potential in the following scenarios:

✅ Multi-RAG orchestration

✅ Agent tool selection

✅ Engineering Change workflows

✅ PLM assistants

✅ SharePoint routing

✅ Confluence routing

✅ Jira ticket management

✅ Intent classification

✅ Confidence-based validation

✅ Hallucination reduction

Final Thoughts

One of the biggest lessons I've learned building GenAI applications is:

Not every problem requires text generation.

Decision-making and text generation are fundamentally different tasks.

Using a decision model before retrieval and generation creates a much cleaner architecture:

 Decision Model
      ↓
  Retrieval
      ↓
     LLM

For enterprise AI systems, agentic workflows, and multi-RAG architectures, this pattern improves reliability, control, and observability.

If you're building AI agents today, I highly recommend experimenting with decision models as part of your architecture.

GitHub Repository

Repository: https://github.com/ujjwalbsoni/strands-decider-end-to-end

About the Author

Ujjwalkumar Soni

Passionate about AI Agents, RAG Architectures, Knowledge Management, and Enterprise GenAI Solutions.

Let's connect and share ideas around Agentic AI and next-generation enterprise applications.

ai #aws #python #rag #agenticai #llm #genai #machinelearning #softwareengineering #opensource

Building Earth Defense: My Journey Creating a Space Shooter Game with Amazon Q Developer

Ujjwal B Soni — Sun, 25 May 2025 23:32:30 +0000

As a developer exploring the potential of AI-assisted coding, I recently embarked on an exciting project to create a space shooter game using Amazon Q Developer. The result is Earth Defense, a Pygame-based asteroid shooter that challenges players to protect Earth from incoming cosmic threats. In this post, I'll share my development journey, the role AI played in the process, and the lessons learned along the way.

The intersection of artificial intelligence and game development has reached an exciting new milestone with Amazon Q Developer CLI, a revolutionary tool that transforms game creation from complex coding endeavors into conversational experiences. Amazon Q represents a paradigm shift in how developers approach game development, offering unprecedented accessibility while maintaining the sophistication needed for engaging gameplay. This comprehensive guide explores every aspect of creating unique games using Amazon Q, from initial setup to advanced development techniques, providing developers at all skill levels with the knowledge needed to bring their gaming visions to life through AI-powered assistance.

What is Earth Defense?

Earth Defense is a classic space shooter game where players control a space shuttle tasked with defending Earth from an endless barrage of asteroids. The game combines nostalgic arcade-style gameplay with modern features like progressive difficulty, power-ups, and a comprehensive scoring system. Players use arrow keys to move their spaceship and the spacebar to shoot missiles, while strategically collecting power-ups to enhance their defensive capabilities.

Setting Up Our Environment

Install PyGame - Follow instructions as per below website

https://www.pygame.org/wiki/GettingStarted

🚀 Getting Started with Amazon Q in Visual Studio Code 🧠💻

🔧 Step-by-Step Installation Guide

Open Visual Studio Code
Go to Extensions
Click on the Extensions icon in the sidebar or press Ctrl+Shift+X.
Search for "Amazon Q"
Look for the official Amazon Q extension (by AWS).
Click “Install”
Sign in with your AWS Builder ID
Once installed, you’ll be prompted to sign in. Use your AWS Builder ID (or create one if you don't have it).
You're all set!
Start chatting with Amazon Q for code suggestions, explanations, documentation, and even architectural guidance.

Key Prompting Strategy: Use Simple, Baby-Friendly Language

Prompt 1 - This prompt will generate initial structure of the project.

Create a game with an idea of saving the earth from Astroids, player should have a space shuttle that will fire missiles on an asteroid. Create this using Pygame. I will explain you all the mechanics step by step and we will add elements as we progress through it

Prompt 2 - Adding the features

i want to add below features. Make this game visually appealing and apply enhancements so that it is smooth and bug free

Score tracking Lives system Different types of asteroids Power-ups Sound effects and background music Better graphics Game levels with increasing difficulty

After few iterations, the game was successfully developed.

GitHub Repo

Unlock Free Machine Learning with Amazon SageMaker Studio Lab: No AWS Account Needed!

Ujjwal B Soni — Fri, 20 Sep 2024 04:14:13 +0000

Are you looking for a FREE machine learning environment to get hands-on experience? Check out Amazon SageMaker Studio Lab! No AWS account or credit card is required—simply sign up with your email and enjoy free access to either a CPU or GPU environment.

It took me just 5 minutes to create an account and start working in the JupyterLab environment.

This differs from Amazon SageMaker Studio, which does require an AWS account and credit card. However, the great thing is that if you begin working in SageMaker Studio Lab and want to scale up to a more powerful environment, you can easily migrate your work to SageMaker Studio to unlock the full capabilities of Amazon SageMaker.

Here’s a quick overview and a link to claim your free environment:

🤑 Free Access: No AWS account or credit card needed. Just sign up with your email and start experimenting!
🥼 JupyterLab Environment: Utilize Jupyter notebooks with AWS computing power.
💻 CPU & GPU Options: Select the right computing resources for your needs, whether you’re a beginner or more advanced.
💾 Persistent Storage: Get 15 GB of storage to keep your projects safe.

🔗https://studiolab.sagemaker.aws/

MachineLearning #AWS #SageMakerStudioLab #DataScience #AWSPartners #GenerativeAI

Exploring Dedicated Virtualization Types in AWS

Ujjwal B Soni — Mon, 03 Jul 2023 17:20:57 +0000

Exploring Dedicated Virtualization Types in AWS
AWS offers two distinct types of dedicated virtualization to cater to different needs: at the host level and at the instance level. This post aims to outline the disparities between these two offerings.

Dedicated Host:

A Dedicated Host consists of dedicated physical hardware exclusively allocated to a single AWS account. It enables the execution of instances of various sizes within a specific instance type. The number of instances is constrained by the available cores on the host.

A Dedicated Host can be shared among multiple organizations or accounts, providing flexibility and resource optimization.

Bring Your Own License (BYOL):
Software licenses often correlate with the number of CPUs, cores, and sockets utilized. With a Dedicated Host, visibility into the core usage of each deployed instance is provided. This enables accurate tracking and validation of license compliance, making it a significant advantage of opting for a Dedicated Host.

Simplified license management can be achieved by utilizing AWS License Manager, which automatically monitors licenses when launching AMIs belonging to a license group.

Host Affinity:
When launching an instance, it is possible to target a specific Dedicated Host by specifying its host ID. This ensures that the instance maintains host affinity upon restarts, maintaining consistent performance and configuration.

Restrictions:

AMIs:

Certain operating systems (OSes) and SQL Server instances require the usage of custom AMIs, as AWS's AMIs are incompatible with Dedicated Hosts.

Host Limit:
While there is a soft limit of 2 Dedicated Hosts per family per region, it can be increased to accommodate higher requirements.

RDS:
AWS Relational Database Service (RDS) instances cannot be launched on Dedicated Hosts.

ASG:
Instances within an Auto Scaling Group (ASG) that target a Dedicated Host must be launched via a Launch Template.

Dedicated Instance:
A Dedicated Instance guarantees that it will be launched on hardware dedicated solely to the corresponding AWS account, without any instances from other accounts. However, it does not provide visibility into the underlying core utilization.

Host Affinity:
Upon restart, a Dedicated Instance may or may not be instantiated on the same physical hardware. Nevertheless, it ensures that the underlying hardware exclusively hosts instances belonging to the same AWS account.

AWS Interface Endpoint vs Gateway Endpoint

Ujjwal B Soni — Mon, 27 Feb 2023 17:30:17 +0000

The connections between your apps and AWS services may need to remain within the AWS network due to security or regulatory reasons, ensuring that no malicious party can tamper with your important data. In this situation, VPC Endpoint can be used. However, there are two different VPC Endpoint kinds from which to select. How do you make the best decision? Does that need you to read through the extensive Amazon documentation of those services?

Fortunately, the decision is easy to make:

1) If the AWS service is either DynamoDB or S3, use Gateway Endpoint.

2) Use the Interface Endpoint for all other purposes.

As most AWS services may be connected privately through this type of endpoint, let's start with Interface VPC Endpoint.

In the diagram below, I have used the private network to link the EC2 instance to the SQS. I created an endpoint network interface in the same subnet as the EC2 instance and attach a security group with the appropriate access permissions to this endpoint networking interface to establish an interface endpoint. The service provider must approve the interface endpoint after it is created. In general, all endpoint requests will be immediately accepted by AWS services and this happens automatically.

Gateway endpoint is a little bit different. In the figure below, the gateway endpoint is created at the VPC level. I need to attach an endpoint policy to the gateway endpoint that allow access to the S3 service and also specify a route in the route table in subnet 10.18.0.0 so the EC2 instance can find a path to the S3 bucket.

In both scenarios, the communications between the service consumer and the service provider never get out of the AWS network hence your data remains secured.

Delete Old Backup/Logfiles/Temp files from EFS using Lambda, PowerShell & Event Bridge

Ujjwal B Soni — Sat, 09 Jul 2022 07:04:47 +0000

Recently i was working on a requirement where a legacy application was migrated to AWS using Lift and Shift strategy. This application used to generate lot of log data and Temporary files.

The log, temp and backup folder size used to reach around 20GB in 2 days, we were using EFS and there were multiple EC2 instances that were connected to EFS.

After analyzing each file we decided that temporary files were just used for pre-processing and they were only required one time so we decided to delete those along with older log files (except access logs) & Old backup files.

I decided to use Powershell Lambda and integrate EFS with Lambda, this function will delete all un-necessary data from EFS. This function will execute periodically using Event Bridge & delete un-necessary files.

We will create Lambda function first using Visual Studio Code

Step 1 : Download Visual Studio Code
Step 2 : Execute below commands in powershell

$region_code = 'ap-south-1' $secretKey='your secret key' $accessKey='your access key'

#Install-Module AWSPowerShell -Scope CurrentUser
#Install-Module AWSLambdaPSCore -Scope CurrentUser

import-Module AWSPowerShell -Force Import-Module AWSLambdaPSCore -Force

#configure script credentials Initialize-AWSDefaultConfiguration -AccessKey $accessKey -SecretKey $secretKey -Region ap-south-1 Set-AWSCredential -AccessKey $accessKey -SecretKey $secretKey -StoreAs default

#shows existing function list from AWS Get-LMFunctionList

Get-AWSPowerShellLambdaTemplate

We'll be using Basic Barebone Script and adding our script commands to it

Create a Starter Lambda function

New-AWSPowerShellLambda -ScriptName DeleteUnusedFiles -Template Basic

You will get this project folder in explorer pane in your Visual Studio Code or else you can import the folder, this project gets created in the same

Step 3 : Add below command to your Powershell script, this is to ensure that our Lambda function is successfully able to get

cd /mnt/efs Remove-Item * -Include *.tmp ls /mnt/efs

Step 4 : upload Lambda function to AWS

$publishPSLambdaParams = @{                                                                       
     name = "DeleteUnusedFiles "
     ScriptPath = ".\DeleteUnusedFiles\DeleteUnusedFiles.ps1"
     Region = "ap-south-1"
     IAMRoleArn = "delete_backup_rp_role"
     }

Publish-AWSPowerShellLambda @publishPSLambdaParams

I have created an EFS file system and Access points as below (You can refer below video for more information on setting up EFS and Mount Targets) :

Below are the details for my Accesspoint:

Once EFS is created and Access points are ready, you need to login to your EC2 instance and mount EFS

1) install EFS Mount Helper

sudo yum install -y amazon-efs-utils

2) create folder as efs

mkdir /efs

3) Mount EFS

sudo mount -t efs -o tls,accesspoint=fsap-9999999999999999 fs-8888888888888888:/ efs

Important Step

Remember to configure security group in EFS as below

Once above steps are completed, we will integrate EFS with Lambda as below:

**** Important, you must associate Lambda to a VPC first, without doing this step, you wont be able to attach EFS

1) Create Role with below permissions and associate it with Lambda function

2) Open your Lambda Function (In this example i am using PowerShell lambda function)
3) Navigate to Configuration tab
4) Open File-System Subtab

Select EFS File System, Access point and Local Mount Point as per below screenshot and Hit save/create button.

Once successfully published you can test your function by opening your Lambda function and clicking on Test, after creating Test event.

As you can see in below screenshot we can see the result of ls command which shows files that are there in the EFS share and hence this shows that we can access the EFS from Lambda.

Once this is successfully created you can schedule your Lambda function using Event Bridge to execute periodically.

Troubleshooting:

If you get an error stating "Cannot configure .NET CLI", open below file from Path in Notepad++

C:\Program Files\WindowsPowerShell\Modules\AWSLambdaPSCore\3.0.1.0\Private_DeploymentFunctions.ps1

Find for keyword $LASTEXITCODE
Comment all occurrence and conditions that are using this variable and run below commands

import-Module AWSPowerShell -Force
Import-Module AWSLambdaPSCore -Force

Try to upload Lambda function again using Powershell, it should work now.

If you have any other comment, suggestion for this post then do let me know.

Please do subscribe my YouTube channel https://www.youtube.com/c/Cloudperceptor/videos

Thanks,
Ujjwalkumar Soni