uv init 06-swarm
cd 06-swarm
uv venv
source .venv/bin/activate
uv add strands-agents strands-agents-tools

import logging
from strands import Agent
from strands.multiagent import Swarm
from strands.models import BedrockModel

# 指定使用Amazon Bedrock上的特定模型版本、使用特定AWS Region
bedrock_model = BedrockModel(
    model_id="us.anthropic.claude-sonnet-4-20250514-v1:0",
    region_name="us-west-2"
)

# Enable debug logs and print them to stderr
logging.getLogger("strands.multiagent").setLevel(logging.DEBUG)
logging.basicConfig(
    format="%(levelname)s | %(name)s | %(message)s",
    handlers=[logging.StreamHandler()]
)

# Create specialized agents
researcher = Agent(name="researcher", model=bedrock_model, system_prompt="You are a research specialist...")
coder = Agent(name="coder", model=bedrock_model, system_prompt="You are a coding specialist...")
reviewer = Agent(name="reviewer", model=bedrock_model, system_prompt="You are a code review specialist...")
architect = Agent(name="architect", model=bedrock_model, system_prompt="You are a system architecture specialist...")

# Create a swarm with these agents, starting with the researcher
swarm = Swarm(
    [researcher, coder, reviewer, architect],
    #entry_point=architect,  # Start with the researcher
    max_handoffs=20,
    max_iterations=20,
    execution_timeout=900.0,  # 15 minutes
    node_timeout=300.0,       # 5 minutes per agent
    repetitive_handoff_detection_window=8,  # There must be >= 3 unique agents in the last 8 handoffs
    repetitive_handoff_min_unique_agents=3
)

# Execute the swarm on a task
result = swarm("Design and implement a simple REST API for a todo app")

# Access the final result
print(f"Status: {result.status}")
print(f"Node history: {[node.node_id for node in result.node_history]}")

# Get performance metrics
print("")
print(f"Total iterations: {result.execution_count}")
print(f"Execution time: {result.execution_time}ms")
print(f"Token usage: {result.accumulated_usage}")

I'll help you design and implement a simple REST API for a todo app. Since this involves both architectural design and coding implementation, I'll hand this off to the architect first to create a solid design foundation.
Tool #1: handoff_to_agent
DEBUG | strands.multiagent.swarm | from_node=<researcher>, to_node=<architect> | handed off from agent to agent
DEBUG | strands.multiagent.swarm | node=<researcher> | node execution completed
DEBUG | strands.multiagent.swarm | current_node=<architect>, iteration=<2> | executing node

The task has been handed off to the architect who will design the system architecture for the todo app REST API. They'll define the data models, API endpoints, and overall structure before we proceed with implementation.

I'll design the architecture for a simple REST API for a todo app. Let me create a comprehensive system design that covers the data models, API endpoints, and overall structure.

## System Architecture Design

### 1. Data Model

Now I'll hand off to the coder to implement this architecture:
Tool #1: handoff_to_agent
DEBUG | strands.multiagent.swarm | from_node=<architect>, to_node=<coder> | handed off from agent to agent
The architecture design is complete! I've provided a comprehensive system design that includes:

he coder willDEBUG | strands.multiagent.swarm | node=<architect> | node execution completed
DEBUG | strands.multiagent.swarm | current_node=<coder>, iteration=<3> | executing node
 now implement this architecture and create a fully functional REST API. After implementation, the reviewer can validate that the code follows the architectural specifications and best practices.I'll implement a complete REST API for the todo app based on the architecture design provided. I'll use Python with Flask and SQLAlchemy for a clean, well-structured implementation.

## Todo REST API Implementation

This implementationDEBUG | strands.multiagent.swarm | node=<coder> | node execution completed
DEBUG | strands.multiagent.swarm | node=<coder> | no handoff occurred, marking swarm as complete
DEBUG | strands.multiagent.swarm | status=<Status.COMPLETED> | swarm execution completed
DEBUG | strands.multiagent.swarm | node_history_length=<3>, time=<78.33>s | metrics
 provides a production-ready REST API for a todo application with all the architectural requirements fulfilled, including proper error handling, validation, and a clean, maintainable codebase.Status: Status.COMPLETED
Node history: ['researcher', 'architect', 'coder']

Total iterations: 3
Execution time: 78332ms
Token usage: {'inputTokens': 5571, 'outputTokens': 6054, 'totalTokens': 11625}

uv init 07-graph
cd 07-graph
uv venv
source .venv/bin/activate
uv add strands-agents strands-agents-tools

import logging
from strands import Agent
from strands.multiagent import GraphBuilder
from strands.models import BedrockModel

# Enable debug logs and print them to stderr
logging.getLogger("strands.multiagent").setLevel(logging.DEBUG)
logging.basicConfig(
    format="%(levelname)s | %(name)s | %(message)s",
    handlers=[logging.StreamHandler()]
)

# 指定使用Amazon Bedrock上的特定模型版本、使用特定AWS Region
bedrock_model = BedrockModel(
    model_id="us.anthropic.claude-sonnet-4-20250514-v1:0",
    region_name="us-west-2"
)

# Create specialized agents
researcher = Agent(name="researcher", model=bedrock_model, system_prompt="You are a research specialist...")
analyst = Agent(name="analyst", model=bedrock_model, system_prompt="You are a data analysis specialist...")
fact_checker = Agent(name="fact_checker", model=bedrock_model, system_prompt="You are a fact checking specialist...")
report_writer = Agent(name="report_writer", model=bedrock_model, system_prompt="You are a report writing specialist...")

# Build the graph
builder = GraphBuilder()

# 添加所有Agent节点
builder.add_node(researcher, "research")
builder.add_node(analyst, "analysis")
builder.add_node(fact_checker, "fact_check")
builder.add_node(report_writer, "report")

# 设置两两之间的关系
# entry point是research agent，然后分别交给analysis和fact_check
builder.add_edge("research", "analysis")
builder.add_edge("research", "fact_check")

# 在analysis和fact_check分别执行完毕后，结果汇总到report
builder.add_edge("analysis", "report")
builder.add_edge("fact_check", "report")

# Set entry points (optional - will be auto-detected if not specified)
builder.set_entry_point("research")

# Optional: Configure execution limits for safety
builder.set_execution_timeout(900)   # 10 minute timeout
builder.set_node_timeout(600)

# Build the graph
graph = builder.build()

# Execute the graph on a task
result = graph("Research the impact of AI on healthcare and create a comprehensive report")

# Access the results
print(f"\nStatus: {result.status}")
print(f"Execution order: {[node.node_id for node in result.execution_order]}")

python graph.py

$ python graph.py 
DEBUG | strands.multiagent.graph | task=<Research the impact of AI on healthcare and create a comprehensive report> | starting graph execution
DEBUG | strands.multiagent.graph | max_node_executions=<None>, execution_timeout=<600>s, node_timeout=<None>s | graph execution config
DEBUG | strands.multiagent.graph | node_id=<research> | executing node

ThisDEBUG | strands.multiagent.graph | node_id=<research>, execution_time=<41520ms> | node completed successfully
DEBUG | strands.multiagent.graph | from=<research>, to=<analysis> | edge ready via satisfied condition
DEBUG | strands.multiagent.graph | from=<research>, to=<fact_check> | edge ready via satisfied condition
DEBUG | strands.multiagent.graph | node_id=<analysis> | executing node
DEBUG | strands.multiagent.graph | node_id=<fact_check> | executing node
 comprehensive report provides a balanced analysis of AI's impact on healthcare, addressing both opportunities and challenges while offering practical recommendations for various stakeholders in the healthcare ecosystem.# Data Analysis Report: AI Healthcare Impact Assessment

**DEBUG | strands.multiagent.graph | node_id=<fact_check>, execution_time=<10952ms> | node completed successfully

**DEBUG | strands.multiagent.graph | node_id=<analysis>, execution_time=<39515ms> | node completed successfully
DEBUG | strands.multiagent.graph | from=<analysis>, to=<report> | edge ready via satisfied condition
DEBUG | strands.multiagent.graph | node_id=<report> | executing node
Analysis Methodology Note:** This assessment utilized quantitative data analysis, trend analysis, comparative performance evaluation, and predictive modeling techniques to provide comprehensive impact assessment of AI in healthcare based on available research data and industry reports.# Comprehensive Report: The Impact of AI on Healthcare

*DEBUG | strands.multiagent.graph | node_id=<report>, execution_time=<56123ms> | node completed successfully
DEBUG | strands.multiagent.graph | status=<Status.COMPLETED> | graph execution completed
This report represents a comprehensive analysis based on current industry research, market data, and implementation experiences. Healthcare organizations should conduct specific assessments of their unique circumstances and requirements when developing AI implementation strategies.*
Status: Status.COMPLETED
Execution order: ['research', 'fact_check', 'analysis', 'report']

uv init 08-workflow
cd 08-workflow
uv venv
source .venv/bin/activate
uv add strands-agents strands-agents-tools

#!/usr/bin/env python3
"""
# Agentic Workflow: Research Assistant

This example demonstrates an agentic workflow using Strands agents with web research capabilities.

## Key Features
- Specialized agent roles working in sequence
- Direct passing of information between workflow stages
- Web research using http_request and retrieve tools
- Fact-checking and information synthesis

## How to Run
1. Navigate to the example directory
2. Run: python research_assistant.py
3. Enter queries or claims at the prompt

## Example Queries
- "Thomas Edison invented the light bulb"
- "Tuesday comes before Monday in the week"

## Workflow Process
1. Researcher Agent: Gathers web information using multiple tools
2. Analyst Agent: Verifies facts and synthesizes findings
3. Writer Agent: Creates final report
"""

from strands import Agent
from strands_tools import http_request
from strands.models import BedrockModel

# 指定使用Amazon Bedrock上的特定模型版本、使用特定AWS Region
bedrock_model = BedrockModel(
    model_id="us.anthropic.claude-sonnet-4-20250514-v1:0",
    region_name="us-west-2"
)

def run_research_workflow(user_input):
    """
    Run a three-agent workflow for research and fact-checking with web sources.
    Shows progress logs during execution but presents only the final report to the user.
    
    Args:
        user_input: Research query or claim to verify
        
    Returns:
        str: The final report from the Writer Agent
    """
    
    print(f"\nProcessing: '{user_input}'")
    
    # Step 1: Researcher Agent with enhanced web capabilities
    print("\nStep 1: Researcher Agent gathering web information...")
    
    researcher_agent = Agent(
        system_prompt=(
            "You are a Researcher Agent that gathers information from the web. "
            "1. Determine if the input is a research query or factual claim "
            "2. Use your research tools (http_request, retrieve) to find relevant information "
            "3. Include source URLs and keep findings under 500 words"
        ),
        model=bedrock_model,
        callback_handler=None,
        tools=[http_request]
    )
    
    researcher_response = researcher_agent(
        f"Research: '{user_input}'. Use your available tools to gather information from reliable sources. "
        f"Focus on being concise and thorough, but limit web requests to 1-2 sources.",
    )
    
    # Extract only the relevant content from the researcher response
    research_findings = str(researcher_response)
    
    print("Research complete")
    print("Passing research findings to Analyst Agent...\n")
    
    # Step 2: Analyst Agent to verify facts
    print("Step 2: Analyst Agent analyzing findings...")
    
    analyst_agent = Agent(
        system_prompt=(
            "You are an Analyst Agent that verifies information. "
            "1. For factual claims: Rate accuracy from 1-5 and correct if needed "
            "2. For research queries: Identify 3-5 key insights "
            "3. Evaluate source reliability and keep analysis under 400 words"
        ),
        model=bedrock_model,
        callback_handler=None
    )

    analyst_response = analyst_agent(
        f"Analyze these findings about '{user_input}':\n\n{research_findings}",
    )
    
    # Extract only the relevant content from the analyst response
    analysis = str(analyst_response)
    
    print("Analysis complete")
    print("Passing analysis to Writer Agent...\n")
    
    # Step 3: Writer Agent to create report
    print("Step 3: Writer Agent creating final report...")
    
    writer_agent = Agent(
        system_prompt=(
            "You are a Writer Agent that creates clear reports. "
            "1. For fact-checks: State whether claims are true or false "
            "2. For research: Present key insights in a logical structure "
            "3. Keep reports under 500 words with brief source mentions"
        ),
        model=bedrock_model
    )
    
    # Execute the Writer Agent with the analysis (output is shown to user)
    final_report = writer_agent(
        f"Create a report on '{user_input}' based on this analysis:\n\n{analysis}"
    )
    
    print("Report creation complete")
    
    # Return the final report
    return final_report


if __name__ == "__main__":
    # Print welcome message
    print("\nAgentic Workflow: Research Assistant\n")
    print("This demo shows Strands agents in a workflow with web research.")
    print("Try research questions or fact-check claims.")
    print("\nExamples:")
    print("- \"What are quantum computers?\"")
    print("- \"Lemon cures cancer\"")
    print("- \"Tuesday comes before Monday in the week\"")
    
    # Interactive loop
    while True:
        try:
            user_input = input("\n> ")
            if user_input.lower() == "exit":
                print("\nGoodbye!")
                break
            
            # Process the input through the workflow of agents
            final_report = run_research_workflow(user_input)
        except KeyboardInterrupt:
            print("\n\nExecution interrupted. Exiting...")
            break
        except Exception as e:
            print(f"\nAn error occurred: {str(e)}")
            print("Please try a different request.")

python workflow.py

Agentic Workflow: Research Assistant

This demo shows Strands agents in a workflow with web research.
Try research questions or fact-check claims.

Examples:
- "What are quantum computers?"
- "Lemon cures cancer"
- "Tuesday comes before Monday in the week"

> What are quantum computers

Processing: 'What are quantum computers'

Step 1: Researcher Agent gathering web information...
Research complete
Passing research findings to Analyst Agent...

Step 2: Analyst Agent analyzing findings...
Analysis complete
Passing analysis to Writer Agent...

Step 3: Writer Agent creating final report...
# What Are Quantum Computers? Research Report

## Executive Summary
Based on comprehensive analysis, quantum computers represent a revolutionary computing paradigm that harnesses quantum mechanical phenomena to solve specific complex problems far more efficiently than classical computers.

## Core Technology Foundation
Quantum computers operate on four fundamental quantum principles:
- **Superposition**: Quantum bits (qubits) exist in multiple states simultaneously, unlike classical bits that are either 0 or 1
- **Entanglement**: Qubits become interconnected with instantaneous state correlations
- **Interference**: Quantum states can be manipulated to amplify correct answers
- **Decoherence**: The fragile nature of quantum states that requires extreme environmental control

These principles enable quantum computers to process vast amounts of information in parallel, providing exponential computational advantages for specific problem types.

## Current Market Status
The quantum computing industry achieved a significant milestone in 2023 with IBM demonstrating "quantum utility" - practical quantum advantage in real-world applications. This marks the transition from experimental research to early commercial viability.

Industry projections estimate the quantum computing market could reach $450-850 billion by 2035, reflecting substantial growth potential despite current technological limitations.

## Practical Applications
Quantum computers excel in specialized areas including:
- **Molecular simulation** for materials science and chemistry
- **Drug discovery** through complex biological modeling  
- **Financial modeling** for risk analysis and optimization
- **Cryptography** and security applications

## Technical Challenges
Current quantum computers require extreme engineering conditions:
- Operation near absolute zero temperatures
- Superconducting materials and specialized hardware
- Sophisticated error correction systems
- Isolation from environmental interference

These requirements make quantum systems complex, expensive, and currently unsuitable for general-purpose computing tasks.

## Key Finding
Quantum computers are specialized problem-solving machines designed to complement, not replace, classical computers. They represent a fundamental shift in computational approach rather than simply faster traditional computing.

**Source**: Analysis based on IBM quantum computing research and industry reports (Reliability: 9/10)Report creation complete