Strands Agents SDK Practical — Optimize Agents with Metrics

from strands import Agent
from strands.models import BedrockModel
from strands_tools import calculator
import json
 
bedrock_model = BedrockModel(
    model_id="us.anthropic.claude-sonnet-4-20250514-v1:0",
    region_name="us-east-1",
)
 
agent = Agent(model=bedrock_model, tools=[calculator], callback_handler=None)
result = agent("What is 123 * 456?")
 
summary = result.metrics.get_summary()
print(json.dumps(summary, indent=2, default=str))

from strands import Agent, tool
from strands.models import BedrockModel
import time
 
bedrock_model = BedrockModel(
    model_id="us.anthropic.claude-sonnet-4-20250514-v1:0",
    region_name="us-east-1",
)
 
@tool
def fast_lookup(key: str) -> str:
    """Look up a value by key (fast operation).
 
    Args:
        key: The key to look up
 
    Returns:
        str: The value
    """
    data = {"name": "Taro", "city": "Tokyo", "lang": "Python"}
    return data.get(key, "Not found")
 
@tool
def slow_analysis(text: str) -> str:
    """Analyze text (slow operation that simulates processing).
 
    Args:
        text: The text to analyze
 
    Returns:
        str: Analysis result
    """
    time.sleep(0.5)
    return f"Analysis of '{text}': {len(text)} chars, {len(text.split())} words"
 
agent = Agent(model=bedrock_model, tools=[fast_lookup, slow_analysis], callback_handler=None)
result = agent("Look up the name and city, then analyze the sentence 'Hello World from Tokyo'")
 
summary = result.metrics.get_summary()
for tool_name, info in summary['tool_usage'].items():
    stats = info['execution_stats']
    print(f"{tool_name}:")
    print(f"  calls={stats['call_count']}, total_time={stats['total_time']:.4f}s, avg_time={stats['average_time']:.4f}s")

from strands import Agent, tool
from strands.models import BedrockModel
 
bedrock_model = BedrockModel(
    model_id="us.anthropic.claude-sonnet-4-20250514-v1:0",
    region_name="us-east-1",
)
 
@tool
def get_exchange_rate(base: str, target: str) -> dict:
    """Get the current exchange rate between two currencies.
 
    Args:
        base: The base currency code
        target: The target currency code
 
    Returns:
        dict: Exchange rate information
    """
    rates = {("USD", "JPY"): 149.50, ("EUR", "USD"): 1.08, ("EUR", "JPY"): 161.46}
    rate = rates.get((base.upper(), target.upper()))
    if rate is None:
        return {"error": f"Rate not found for {base}/{target}"}
    return {"base": base.upper(), "target": target.upper(), "rate": rate}
 
@tool
def convert_currency(amount: float, rate: float) -> dict:
    """Convert an amount using a given exchange rate.
 
    Args:
        amount: The amount to convert
        rate: The exchange rate to apply
 
    Returns:
        dict: Conversion result
    """
    return {"original": amount, "rate": rate, "converted": round(amount * rate, 2)}
 
agent_a = Agent(model=bedrock_model, tools=[get_exchange_rate, convert_currency], callback_handler=None)
result_a = agent_a("Convert 1000 EUR to JPY")
summary_a = result_a.metrics.get_summary()
 
@tool
def convert_with_rate(amount: float, base: str, target: str) -> dict:
    """Convert currency amount from base to target currency.
 
    Args:
        amount: The amount to convert
        base: The base currency code
        target: The target currency code
 
    Returns:
        dict: Conversion result with rate
    """
    rates = {("USD", "JPY"): 149.50, ("EUR", "USD"): 1.08, ("EUR", "JPY"): 161.46}
    rate = rates.get((base.upper(), target.upper()))
    if rate is None:
        return {"error": f"Rate not found for {base}/{target}"}
    return {"base": base, "target": target, "rate": rate, "original": amount, "converted": round(amount * rate, 2)}
 
agent_b = Agent(model=bedrock_model, tools=[convert_with_rate], callback_handler=None)
result_b = agent_b("Convert 1000 EUR to JPY")
summary_b = result_b.metrics.get_summary()
 
print("=== Comparison ===")
print(f"Cycles: {summary_a['total_cycles']} vs {summary_b['total_cycles']}")
print(f"Tokens: {summary_a['accumulated_usage']['totalTokens']} vs {summary_b['accumulated_usage']['totalTokens']}")
print(f"Duration: {summary_a['total_duration']:.2f}s vs {summary_b['total_duration']:.2f}s")