Forem: Rini Susan V S

Tying It All Together : How Strands Agents Enhance Retail Agent Performance Analysis

Rini Susan V S — Tue, 30 Sep 2025 07:45:21 +0000

Background

Strands Agents is a simple-to-use, code-first framework for building agents. It is an open-source SDK by Amazon Web Services [AWS]. Strands comprise three key components: a language model, a system prompt, and a set of tools. Strands supports multiple agent architecture patterns, scaling from a single agent up to complex networks of agents.

Strands is not tied to a single LLM provider, and can work with models on Amazon Bedrock by default. It also supports open source models such as LlamaAPI, Ollama, OpenAI, and others. Strands supports running agents in various environments – including Amazon EC2, AWS Lambda, AWS Fargate, and Amazon Bedrock AgentCore.

Software performance testing evaluates how retail applications behave under various workloads and conditions, ensuring a reliable customer experience. This is crucial for systems such as e-commerce platforms, point-of-sale systems, and inventory management. Identifying and resolving performance bottlenecks before they impact users minimizes lost sales.

The rise of Large Language Models [LLMs] and Generative AI presents new challenges for performance testing and engineering. Unlike traditional applications, testers now deal with dynamic, context-aware AI agents that interact with different knowledge bases and tools.

The Use Case: A Retail Customer Support Agent

Preamble
Imagine a customer support agent for an e-commerce company that

Answer policy questions by searching the Knowledge Base
Check order status by calling an API through an Action Group.
Consolidate information and provide a helpful response to the customer.

In production, performance is critical, and even a 10-second delay can lead to a frustrated customer and a lost sale.

The Performance Puzzle
The total time a user waits for an answer is the sum of several processes. The Strands Agents framework provides visibility to understand each of these steps. The agent's trace usually includes:

Orchestration & Reasoning: The agent's underlying Foundation Model (FM) interprets the user's prompt and decides what to do.
Knowledge Base Retrieval: If it's a policy question, the agent queries the knowledge base.
Action Group Invocation: To check an order, the agent triggers a Lambda function that calls an internal Order Status API.
Final Response Generation: The retrieved information is passed back to the LLM, which generates the final response.

Strands Agents in Action

The Jupyter Notebook walks through the process of creating an Agent, based on the e-commerce customer support use case described earlier.

Prerequisites:

An active AWS account.
An Amazon Bedrock Agent created with:
A Knowledge Base attached
An Action Group configured to invoke a Lambda function for checking order status.
The agentId and agentAliasId of your created agent.
The boto3 library installed and configured with appropriate IAM permissions

Helper Function to Invoke the Agent
Using the Strands SDK's tool interfaces, we can build our own custom tools. Any Python function can be used as a tool by using the @tool decorator.
Create a reusable function to invoke our agent. This function will capture the agent's response and also the full trace of its internal operations, which is crucial for performance analysis.

from strands.tools import tool
@tool
def invoke_bedrock_agent(prompt: str, session_id: str):
    """
    Invokes the Bedrock agent, captures the response, and returns the full event stream.

    Args:
        prompt (str): The user's query for the agent.
        session_id (str): A unique identifier for the conversation session.

    Returns:
        list: A list of all events received from the agent's response stream.
    """
    print(f"\nUser prompt: '{prompt}'")

    events = []
    start_time = time.time()

    try:
        response = bedrock_agent_runtime_client.invoke_agent(
            agentId=AGENT_ID,
            agentAliasId=AGENT_ALIAS_ID,
            sessionId=session_id,
            inputText=prompt,
            enableTrace=True # CRITICAL: This enables the detailed trace!
        )

        event_stream = response['completion']
        for event in event_stream:
            events.append(event)

        final_response = ""

        trace_data = None
        # Extract the final response and the trace data
        for event in events:
          if 'chunk' in event:
            final_response += event['chunk']['bytes'].decode('utf-8')
          if 'trace' in event:
            trace_data = event['trace']['trace']

    except Exception as e:
        print(f"An error occurred: {e}")
        return None
    finally:
        end_time = time.time()
        print("")
        print(f"Total Latency: {end_time - start_time:.2f} seconds")

    return events

Performance Test Scenarios
Let’s run a few tests to establish a baseline for different types of queries.

Scenario A: Knowledge Base Query
This tests the agent's ability to retrieve information from the attached knowledge base. The primary latency here will be in the Retrieve step.
session_id_kb = str(uuid.uuid4()) prompt_kb = "What is the return policy for clothes?" kb_events = invoke_bedrock_agent(prompt_kb, session_id_kb)
Scenario B: Action Group Query (API Call)
This tests the agent's ability to invoke an external tool (our order status Lambda). Latency will be a combination of reasoning and the actual Lambda/API execution time.
session_id_ag = str(uuid.uuid4()) prompt_ag = "Can you check the status for order #B-98765?" ag_events = invoke_bedrock_agent(prompt_ag, session_id_ag)

Analyzing the Performance Trace
The real value comes from parsing the trace data returned in the event stream. Create a function, trace_analysis() to extract and analyze this data, and use @tool decorator.

Invoke the trace_analysis function with knowledge base events and action group events data.

def trace_analysis(kb_events)
def trace_analysis(ag_events)

Strands Agent Function

import strands from strands import Agent agent = Agent( tools=[trace_analysis,invoke_bedrock_agent] )

Strands Agent - Knowledge Base Query

Strands Agent – Lambda Function Invocation

CloudWatch Monitoring

The token count and invocation latency can also be observed in AWS Cloud Watch, under GenAI Observability section.

Performance Insights and Optimization Actions

Knowledge Base Bottleneck: If the "Knowledge Base Retrieval Time" is high, need to investigate the knowledge base settings. Are you retrieving too many chunks? Is the vector database under-provisioned?
API Bottleneck: If the "Lambda/API Call Time" is high, the performance issue lies outside of Bedrock. You need to use tools like AWS X-Ray and CloudWatch Logs to optimize the Lambda function and any downstream services it calls.
Model Latency: If "Final Response Generation Latency" is high, consider switching to a faster, more cost-effective model. Refine agent's instructions to produce more concise answers, thereby reducing the outputTokenCount.

References

Amazon Nova Canvas : opening up new canvases

Rini Susan V S — Mon, 19 May 2025 07:28:26 +0000

Background

Amazon Nova is a new generation of foundation models available on Amazon Bedrock. Nova includes four understanding models, two creative content generation models, and one speech-to-speech model. The content generation models include Amazon Nova Canvas for image generation and Amazon Nova Reel for video generation.

Amazon Nova Canvas

Amazon Nova Canvas is an image generation model that creates professional-grade images from text and image inputs. Amazon Nova Canvas is ideal for various applications such as marketing and reporting. It supports features like:

Text-to-image generation – Input a text prompt and generate an image as output.
Image editing options – inpainting, outpainting, generating variations, and automatic editing.
Color-guided content – input a list of hex color codes with a text prompt.
Background removal – identifies multiple objects in the input image and removes the background.

Nova Canvas in Amazon Bedrock Playground

It was a fun experience to try out the Nova Canvas model in the Amazon Bedrock playground. Being interested in photography, I wanted to evaluate how realistic the Nova model images were and know if the quality was similar to what Amazon claims.

Below is an image of Yosemite National Park, which I have taken near the Tunnel View point.

I tried to generate a similar image in Amazon Bedrock Playground, using the Nova Canvas model.

I was amazed to see how easily we could generate quality images using a few prompts. Yes, the experience of viewing the natural wonder in person is definitely rewarding. But time, effort, and cost factors are low in this option. The Amazon Canvas model can come in handy in case of weekly or monthly newsletters that need to have catchy cover pages or images related to a topic.

Nova Canvas in Python Notebook

Amazon Nova also provides the option for image generation using Python notebooks, apart from the Bedrock playground. One method of invoking the Amazon Nova models is via the Invoke API. Provided below is the Python code to generate the above image programmatically.

# Install libraries
!pip install boto3

# Import necessary libraries
import base64
import json
import random
import boto3
from PIL import Image
import io
import os

# Get AWS Credentials from secrets
AWS_ACCESS_KEY_ID=os.getenv('AWS_ACCESS_KEY_ID')
AWS_SECRET_ACCESS_KEY=os.getenv('AWS_SECRET_ACCESS_KEY')
AWS_DEFAULT_REGION=os.getenv('AWS_DEFAULT_REGION')

# Create a Bedrock Runtime client
client = boto3.client(
    "bedrock-runtime",
    region_name=AWS_DEFAULT_REGION,
    aws_access_key_id=AWS_ACCESS_KEY_ID,
    aws_secret_access_key=AWS_SECRET_ACCESS_KEY
)

# Set the model ID for Nova Canvas
model_id = "amazon.nova-canvas-v1:0"

# Define the image generation prompt
prompt = "Generate a realistic-looking image of Yosemite from the tunnel view. The picture was taken during the summer season at noon."

# Generate a random seed
seed = 12

# Format the request payload
request_body = {
    "taskType": "TEXT_IMAGE",
    "textToImageParams": {"text": prompt},
    "imageGenerationConfig": {
        "seed": seed,
        "quality": "standard",
        "height": 1024,
        "width": 512,
        "numberOfImages": 1,
        "cfgScale": 8.0
    }
}

# Invoke the model
response = client.invoke_model(
    body=json.dumps(request_body),
    modelId=model_id,
    contentType="application/json",
    accept="application/json"
)
# Parse the response
response_body = json.loads(response["body"].read())
image_data = base64.b64decode(response_body["images"][0])

# Save the image
output_dir = "generated_images"
os.makedirs(output_dir, exist_ok=True)
output_path = os.path.join(output_dir, f"nova_canvas_image_{seed}.png")

image = Image.open(io.BytesIO(image_data))
image.save(output_path)
print(f"Image saved to: {output_path}")`

Security Guardrails in Amazon Nova

The Nova Canvas model available through Amazon Bedrock comes with integrated security guardrails. Guardrails help evaluate user inputs and model responses based on specific policies and provide safeguards to help build generative AI applications securely.

For example, if you try a non-safe prompt in Nova Canvas, the image won’t be generated, and a warning text message will be displayed as shown below.

Areas of Improvement

The following are some features of Amazon Nova Canvas model, that needs enhancement

Input text size limit [ 1024 characters]
Input image size limit [ longest side not exceeding 4096 pixels]
No 3D image generation [ currently 2D image generation]

Closing Thoughts

The Amazon Nova Canvas model is an excellent content generation model that can aid in prototyping, social media marketing, and advertising campaigns. It can be easily integrated into Generative AI applications. The security guardrails can ensure that the input prompt and the generated response don’t violate any safety policies. The foundation models are evolving rapidly, and the Amazon Nova Canvas model also has scope to improve.