用自然语言在 Amazon Bedrock AgentCore 上构建仪表板自动化智能体

from strands import Agent, tool
from strands.models import BedrockModel

@tool

def find_dashboard_tool(dashboard_name: str = "") -> str:
  """Find Quick dashboards by name (supports partial matching)"""
  client = boto3.client('quicksight', region_name=REGION)

  response = client.list_dashboards(AwsAccountId=AWS_ACCOUNT_ID)

  dashboards = response.get('DashboardSummaryList', [])

  # List all dashboards if no search term provided

  if not dashboard_name or dashboard_name.strip() == "":
   all_names = [d['Name'] for d in dashboards]
   return f"All dashboards ({len(all_names)}): {all_names}"

  # Filter using case-insensitive partial matching

  matches = [d['Name'] for d in dashboards if dashboard_name.lower() in d['Name'].lower()]
      return f"Found {len(matches)} dashboards: {matches}"

_find_agent = Agent(
  model=BedrockModel(model_id=MODEL_ID),
  tools=[find_dashboard_tool, get_columns_tool],
  system_prompt="You are the Find Dashboard Agent. Help users find dashboards and view columns."

)

@tool

def find_dashboard_agent(query: str) -> str:
 """Agent wrapper exposed as a tool for the orchestrator to invoke"""
 response = _find_agent(query)
 return str(response)

@tool

def modify_dashboard(dashboard_name: str, action: str, column_name: str) -> str:
"""Modify a dashboard by adding or removing columns"""
client = boto3.client('quicksight', region_name=REGION)
info = _get_dashboard_and_dataset_info(dashboard_name)

# Validation-first: verify column state before making changes
if action == "add":
if column_name in info["dashboard_columns"]:
return f"Column '{column_name}' is already in the dashboard."
if column_name not in info["dataset_columns"]:
return f"Column '{column_name}' doesn't exist in dataset."
elif action == "remove":
if column_name not in info["dashboard_columns"]:
return f"Column '{column_name}' is not in the dashboard."

# Update table visual field wells in the dashboard definition
updated_definition = info["definition"]
for sheet in updated_definition.get('Sheets', []):
for visual in sheet.get('Visuals', []):
if 'TableVisual' in visual:
field_wells = visual['TableVisual']['ChartConfiguration']['FieldWells']
existing_fields = field_wells['TableAggregatedFieldWells']['GroupBy']
if action == "add":
existing_fields.append({
'CategoricalDimensionField': {
'FieldId': str(uuid.uuid4()),
'Column': {
'DataSetIdentifier': dataset_id,
'ColumnName': column_name
}
}
})

elif action == "remove":
existing_fields = [f for f in existing_fields\
if f['CategoricalDimensionField']['Column']['ColumnName'] != column_name]

# Create new dashboard with UUID suffix, original is preserved for rollback
new_uuid = str(uuid.uuid4())[:8]
client.create_dashboard(
AwsAccountId=AWS_ACCOUNT_ID,
DashboardId=f"dashboard_{new_uuid}",
Name=f"{info['dashboard_name']}_dashboard_{new_uuid}",
Definition=updated_definition
)

_modify_agent = Agent(
model=BedrockModel(model_id=MODEL_ID),
tools=[modify_dashboard],
system_prompt="You are the Modify Dashboard Agent. You add or remove columns from dashboards."
)

@tool
def modify_dashboard_agent(query: str) -> str:
"""Agent wrapper for the orchestrator to invoke with natural language"""
response = _modify_agent(query)
return str(response)

from find_dashboard_agent import find_dashboard_agent
from modify_dashboard_agent import modify_dashboard_agent
orchestrator = Agent(
model=BedrockModel(model_id=MODEL_ID),
tools=[find_dashboard_agent, modify_dashboard_agent],
system_prompt="""You are an Amazon Quick Orchestrator. Route user requests to specialized agents.

AGENTS:
- find_dashboard_agent: Finding dashboards, listing, showing columns
- modify_dashboard_agent: Adding/removing columns

ROUTING LOGIC:
- "find", "show", "list", "get", "columns" → find_dashboard_agent
- "add", "remove", "modify", "delete" → modify_dashboard_agent"""
)

app = BedrockAgentCoreApp()
@app.entrypoint
def invoke(payload):
user_input = payload.get("prompt", "")
response = orchestrator(user_input)
return response.message['content'][0]['text']

uv add bedrock-agentcore strands-agents strands-agents-tools

uv add --dev bedrock-agentcore-starter-toolkit

# For Linux/macOS

source .venv/bin/activate

# For Windows

source .venv/Scripts/activate

agentcore configure --entrypoint agent.py --name qs_selfservice_agent

Detected dependency file: pyproject.toml
Press Enter to use this file, or type a different path (use Tab for autocomplete):
Path or Press Enter to use detected dependency file: pyproject.toml
✓ Using requirements file: pyproject.toml
Deployment Configuration
Select deployment type:
Direct Code Deploy (recommended) - Python only, no Docker required
Container - For custom runtimes or complex dependencies
Choice [1]: 1
Select Python runtime version:
PYTHON_3_10
PYTHON_3_11
PYTHON_3_12
PYTHON_3_13
Choice [4]: 4 ✓ Deployment type: Direct Code Deploy (python.3.13)
Execution Role
Press Enter to auto-create execution role, or provide execution role ARN/name to use existing
Execution role ARN/name (or press Enter to auto-create):
✓ Will auto-create execution role
S3 Bucket Press Enter to auto-create S3 bucket, or provide S3 URI/path to use existing S3 URI/path (or press Enter to auto-create):
✓ Will auto-create S3 bucket
Authorization Configuration  Note: AgentCore uses IAM authorization.
Configure OAuth authorizer instead? (yes/no) [no]:
✓ Using default IAM authorization
Request Header Allowlist Configure which request headers are allowed to pass through to your agent.
Common headers: Authorization, X-Amz-Bedrock-AgentCore-Session-.
Configure request header allowlist? (yes/no) [no]:
✓ Using default request header configuration
Configuring BedrockAgentCore agent: Agent1

Memory Configuration
Tip: Use --disable-memory flag to skip memory entirely

MemoryManager initialized for region: us-east-1
Existing memory resources found:
1. agent_mem-RLr7b8Hsif
ID: agent_mem-RLr7b8Hsif
2. orchestrator_agent_mem-kP9yQc96nd
ID: orchestrator_agent_mem-kP9yQc96nd
Options:
• Enter a number to use existing memory
• Press Enter to create new memory
• Type 's' to skip memory setup
Your choice:
✓ Short-term memory will be enabled (default)
• Stores conversations within sessions
• Provides immediate context recall

Optional: Long-term memory
• Extracts user preferences across sessions
• Remembers facts and patterns
• Creates session summaries
• Note: Takes 120-180 seconds to process

Enable long-term memory? (yes/no) [no]:
✓ Using short-term memory only
Will create new memory with mode: STM_ONLY
Memory TTL duration: Short term only
Network mode: PUBLIC
Changing default agent from 'Agent1' to 'Agent2'

agentcore launch

aws bedrock-agentcore delete-agent-runtime --agent-id <agent-id> --region <region>

aws ecr delete-repository --repository-name <repository-name> --region <region> --force

aws quicksight delete-dashboard --aws-account-id <account-id> --dashboard-id <dashboard-id> --region <region>

aws logs delete-log-group --log-group-name /aws/bedrock/agentcore/<agent-id> --region <region>