以Kiro快速部署云上Agent：只需几个小时，从业务需求到部署于Amazon Bedrock Agentcore落地

业务需求 
创建自动化金融逾期处理流程Multi Agent，从逾期开始到触达处理结束，使传统处理流程中的人工步骤都由Agent实现。
业务流程参考Flows.txt，从逾期识别-->画像评分-->分拨决策-->触达执行流程，无需后续合规质检和绩效监控流程

技术要求
重点是创建多Agent架构自动化实现流程，模拟逾期金融数据和客户特征画像，进行评分，自动进入案件池，触发通知客户。触达流程分阶段部署，第一阶段使用SNS发送邮件通知。等所有流程完成之后，第二阶段使用Amazon Connect外呼系统，并结合Nova Sonic语音服务。
使用Strands Agent SDK，部署在Amazon Agentcore。
简化其他技术组件，不需要Kafka, Flink, Clickhouse等模块。实时和离线数据源统一使用Aurora Postgresql，特征和分析数据也使用Aurora Postgresql。

Separate backend & frontend. Backend Python language, deploy on ECR + Fargate. Frontend: React & Node.js, request routes to backend. By frontend, business operator can view business dashboard and risk details. Run all programs directly instead of docker, unless at Agentcore deployment stage. 
Deploy multi agents in Agentcore Runtime. Make sure LLM reasoning is used. Orchestrator agent processes requests, invoke other agents to finish business process. Data agent query and write business data. User, order, events and processing data are stored in Aurora Postgresql database.
Each conversation generates an Agentcore Runtime Session and stores the conversation history in Agentcore Memory, including short-term and long-term memories.
Using Cognito as user authentication, integrated with Agentcore Runtime authentication.

技术规范
DO NOT use any Cloudformation.
Use real AWS services rather than simulated functionality.
Store all test scripts in directory "tests", documentation in directory "docs".
Refer to Kiro Power for Strands Agents SDK& AgentCore to deploy according to best practices.

开发部署流程
Credential: Use .env file for environment config.  Local credential in development environment, production environment can be switched to role.
1.Initialize related AWS services. Make sure each service can be called well.
AWS region: us-west-2, environment config with local credential
LLM Model: Amazon Nova Pro
Set up IAM roles to access all needed AWS services, including Bedrock, AgentCore, Database Data API, ECS Fargate, Secret Manager, S3, etc.
Aurora Postgresql Serverless with Data API & Secret Manager. Initialize some business related data in this financial scenario.
SNS with email
2.Development multiple agents locally. Make sure all agents run with real Bedrock Nova LLM reasoning, access real Aurora database. Follow Agentcore development best practice.
3.Test all agents run business flow correctly in local host. Create test cases for each agent, and integration, simulate real cases.
4.If local test fine, change env production env with role. Deploy agents to Agentcore Runtime with production env. Make sure configure Agentcore Runtime with HTTP 8080 port, following Agentcore deployment best practice.
5.Create backend with Python for calling agents. Test backend integrated with Agentcore. If fine, deploy backend to ECS Fargate.
6.Create React & Node.js front-end UI, for business operator, including user interfaces, and login authentication. 
7.Test full process from frontend to backend & Agentcore.
8.Deploy frontend to Cloudfront + s3. Remember DO NOT make S3 public access. Make sure Cloudfront origin access control for secure access.

## Requirements
### Requirement 1: Multi-Agent Architecture
**User Story:** As a financial institution, I want an automated multi-agent system to handle overdue processing, so that manual intervention is eliminated while maintaining processing quality.
#### Acceptance Criteria
1. THE Orchestrator_Agent SHALL receive processing requests and coordinate other agents to complete business workflows
2. WHEN a business process requires data operations, THE Orchestrator_Agent SHALL invoke the Data_Agent using AgentCore Runtime API calls
3. WHEN customer profiling is needed, THE Orchestrator_Agent SHALL invoke the Scoring_Agent using AgentCore Runtime API calls
4. WHEN distribution decisions are required, THE Orchestrator_Agent SHALL invoke the Allocation_Agent using AgentCore Runtime API calls
5. WHEN customer outreach is needed, THE Orchestrator_Agent SHALL invoke the Outreach_Agent using AgentCore Runtime API calls
6. THE System SHALL deploy all agents in AgentCore_Runtime with proper session management
7. THE System SHALL use Nova_Pro LLM for all agent reasoning and decision-making
8. THE Orchestrator_Agent SHALL use boto3 bedrock-agentcore client to make actual agent invocation calls
9. THE System SHALL pass session IDs between agent calls to maintain workflow context
### Requirement 2: Overdue Identification and Case Management
**User Story:** As a business system, I want to automatically detect overdue events and create cases, so that processing can begin immediately without manual intervention.
#### Acceptance Criteria
1. WHEN a payment due date passes without payment, THE System SHALL automatically detect the overdue event
2. WHEN an overdue event is detected, THE Data_Agent SHALL create a new case record in the Case_Pool
3. WHEN a case is created, THE System SHALL include user ID, overdue amount, and payment plan details
4. WHEN a case enters the Case_Pool, THE System SHALL trigger the profiling and scoring workflow
5. THE System SHALL maintain case status throughout the processing lifecycle

### Multi-Agent Pattern Selection
Based on the Strands framework analysis, this system uses a **hybrid approach**:
1. **Workflow Pattern** for the core business process: The overdue processing follows a deterministic DAG (Directed Acyclic Graph) where each stage has clear dependencies and parallel execution opportunities.
2. **Orchestrator Agent** for coordination: A central agent manages the workflow execution, handles error conditions, and maintains session state across the entire process.
3. **Specialized Agents** for domain expertise: Each agent focuses on a specific business capability with appropriate tools and LLM reasoning.
## Components and Interfaces
### 1. Orchestrator Agent
**Purpose**: Central coordination and workflow management
**LLM Model**: Amazon Nova Pro
**Key Responsibilities**:
- Receive and parse business requests
- Coordinate workflow execution across specialized agents
- Maintain session state and conversation history
- Handle error conditions and retry logic
- Provide status updates to backend API
### 2. Data Agent
**Purpose**: Database operations and data management
**LLM Model**: Amazon Nova Pro
**Key Responsibilities**:
- Execute CRUD operations on Aurora PostgreSQL
- Manage case lifecycle and status updates
- Retrieve customer profiles and historical data
- Store processing results and audit trails
**Tools**:
- `query_database`: Execute SELECT queries with parameterization
- `insert_case`: Create new overdue cases
- `update_case_status`: Update case processing status
- `get_customer_profile`: Retrieve comprehensive customer data
- `store_processing_result`: Save agent processing outcomes
### 3. Scoring Agent
**Purpose**: Customer profiling and risk assessment
**LLM Model**: Amazon Nova Pro
**Key Responsibilities**:
- Calculate B-Card scores (behavioral risk assessment)
- Calculate C-Card scores (repayment probability)
- Analyze multi-source customer data
- Generate risk profiles and recommendations
**Tools**:
- `calculate_b_card_score`: Behavioral risk scoring algorithm
- `calculate_c_card_score`: Repayment probability scoring
- `analyze_transaction_patterns`: Transaction behavior analysis
- `assess_payment_history`: Historical payment performance analysis
- `generate_risk_profile`: Comprehensive risk assessment
### 4. Allocation Agent
**Purpose**: Distribution decision-making and strategy application
**LLM Model**: Amazon Nova Pro
**Key Responsibilities**:
- Apply business rules for case routing
- Determine optimal outreach channels
- Select appropriate message templates
- Calculate priority scores and timing
**Tools**:
- `apply_allocation_rules`: Execute business rule engine
- `select_outreach_channel`: Determine communication method
- `choose_message_template`: Select appropriate messaging
- `calculate_priority_score`: Determine case urgency
- `optimize_contact_timing`: Find optimal contact windows
### 5. Outreach Agent
**Purpose**: Customer communication execution
**LLM Model**: Amazon Nova Pro
**Key Responsibilities**:
- Execute Phase 1 email notifications via SNS
- Execute Phase 2 voice calls via Amazon Connect
- Handle communication compliance and frequency limits
- Process customer responses and outcomes
**Tools**:
- `send_email_notification`: SNS email delivery
- `initiate_voice_call`: Amazon Connect call initiation
- `check_compliance_limits`: Validate communication rules
- `process_customer_response`: Handle inbound responses
- `record_communication_outcome`: Log results and status

## Overview
This implementation plan converts the multi-agent financial overdue processing system design into discrete coding tasks. The approach follows a phased deployment strategy: Phase 1 implements email notifications via SNS, Phase 2 adds voice calls via Amazon Connect. All agents are built using Python with Strands Agent SDK and deployed on Amazon AgentCore Runtime.
## Tasks
- [x] 1. Initialize AWS Infrastructure and Services
  - Set up AWS region (us-west-2) with local credentials for development
  - Configure IAM roles for Bedrock, AgentCore, Aurora, SNS, and other AWS services
  - Initialize Aurora PostgreSQL Serverless with Data API and Secret Manager
  - Set up Amazon SNS for email notifications
  - Configure Amazon Bedrock Nova Pro model access
  - Create sample financial business data for testing scenarios
  - _Requirements: 10.3, 10.4, 10.5, 12.4_
- [x] 2. Set up Development Environment and Configuration
  - Create .env file structure for environment configuration
  - Install Strands Agent SDK and AgentCore development tools
  - Configure local development credentials and AWS service access
  - Set up project directory structure for multi-agent system
  - Initialize Aurora PostgreSQL database schema with business tables
  - _Requirements: 12.1, 12.5_
- [x] 3. Implement Database Schema and Data Models
  - [x] 3.1 Create core database tables (cases, customer_profiles, communications, allocation_rules)
    - Design and implement cases table with overdue processing lifecycle
    - Create customer_profiles table for risk assessment data
    - Build communications table for outreach history and outcomes
    - Implement allocation_rules table for business rule engine
    - _Requirements: 7.1, 7.3_
  - [ ]* 3.2 Write property test for database schema integrity
    - **Property 9: Unified Data Storage Consistency**
    - **Validates: Requirements 7.1, 7.2, 7.3, 7.4, 7.5**
  - [x] 3.3 Create data access layer with Aurora PostgreSQL Data API integration
    - Implement database connection management with Secret Manager
    - Create CRUD operations for all business entities
    - Add transaction management and connection pooling
    - _Requirements: 7.2, 10.4_
  - [x] 3.4 Validate Bedrock Nova LLM and Aurora PostgreSQL Integration
    - Comprehensive integration testing of Bedrock Nova Pro model
    - Validate Aurora PostgreSQL Data API connectivity and operations
    - Test LLM + Database integration for financial risk assessment
    - Verify performance and reliability of both services working together
    - _Requirements: 1.7, 7.2, 10.4_

@app.entrypoint
def invoke(payload, context):
    """
    Main entry point for overdue processing requests
    Args:
        payload: {
            "action": "process_overdue",
            "user_id": "string",
            "case_id": "string", 
            "overdue_amount": float,
            "session_id": "string"
        }
        context: AgentCore runtime context
    Returns:
        {
            "status": "success|error|in_progress",
            "case_id": "string",
            "current_stage": "string",
            "result": dict,
            "error_message": "string"
        }
    """

    @tool
    def analyze_customer_data(self, user_id: str) -> Dict[str, Any]:
        """
        Use Nova Pro LLM to analyze customer data and provide insights
        Args:
            user_id: The unique identifier for the customer
        Returns:
            LLM analysis and insights about the customer
        """
        try:
            # Get customer profile
            profile = data_access.get_customer_profile(user_id)
            if not profile:
                return {
                    "success": False,
                    "message": f"No customer profile found for user {user_id}"
                }
            # Create analysis prompt
            prompt = f"""
You are a financial risk analyst. Analyze this customer profile and provide insights:
Customer ID: {profile.user_id}
Transaction Volume: ${profile.transaction_volume:,.2f}
Average Monthly Spend: ${profile.avg_monthly_spend:,.2f}
Payment History Score: {profile.payment_history_score:.2f} (0-1 scale)
App Activity Score: {profile.app_activity_score:.2f} (0-1 scale)
External Credit Score: {profile.external_credit_score}
Current Risk Category: {profile.risk_category.value}
Preferred Contact: {profile.preferred_contact_method.value}
Provide:
1. Risk assessment summary
2. Key behavioral indicators
3. Recommended engagement strategy
4. Potential concerns or red flags
Keep response concise and actionable.
"""
            # Get LLM analysis
            analysis = llm_client.invoke_model(prompt, max_tokens=400, temperature=0.2)
            return {
                "success": True,
                "data": {
                    "user_id": user_id,
                    "analysis": analysis,
                    "profile_summary": {
                        "risk_category": profile.risk_category.value,
                        "payment_score": profile.payment_history_score,
                        "credit_score": profile.external_credit_score,
                        "preferred_contact": profile.preferred_contact_method.value
                    }
                },
                "message": f"Customer analysis completed for user {user_id}"
            }
        except Exception as e:
            return {
                "success": False,
                "error": str(e),
                "message": f"Error analyzing customer data for user {user_id}"
            }

Create a Smart Allergen Cartoonizer (Smart Allergen Cartoonizer) on Amazon AgentCore
Business process:
1. Users upload allergen test reports to S3 by uploading or taking pictures
2. Identifying the abnormal portion of the allergen report: Bedrock LLM (Amazon Nova Pro)
3. Generate a cartoon image (Bedrock LLM Amazon Nova Canvas) to give patients a more specific allergen risk profile (Bedrock LLM Amazon Nova Premium)
4. Once the patient sees it, remind the user to click Next to get the solution (Bedrock LLM Amazon Nova Premium)
 
Requirements:
1. Allergens are limited to mites. An LLM is required to generate a mite profile picture to be used for different levels of allergies
2. Involves scientific research and requires the preservation of all original documents
3. Data privacy protection, patient information desensitization
4. Provide solutions based on different user data
5. RAG vector library: user documents are vectorized and administrators can also add medical industry documents to gain more expertise
6. The administrator interface can view user statistics and manage the RAG documents uploaded by itself
 
Technical highlights:
AWS region: us-west-2
LLM Model: Amazon Nova Premium as agent processing and analysis. Amazon Nova Canvas generates images, pre-generates multiple allergy level images, and stores them in S3, and can be directly used in customer processes
Run the Agentcore Runtime using the Agentcore Agent SDK. Agents can communicate with customers, answer questions, and run business processes. The agent language uses Python and doesn't use Docker, unless it reaches the Agentcore deployment stage. Create a separate directory for each agent, add AgentCore Runtime entry point files separately, use BedrockAgentCoreApp Decorator, and import agent files, so agents can run locally or Agentcore. All agents expose HTTP 8080 port, path /invocations, and /ping health checks.
Each conversation generates an Agentcore Runtime Session and stores the conversation history in Agentcore Memory, including short-term and long-term memories.
Using Cognito as a user authentication system, Agentcore Runtime combines Cognito authentication.
User data is stored in a database, and current report data and historical data can be viewed. Databases: Aurora Postgresql Serverless uses Data API & Secret Manager to access and create user and business sample data. The database enables pgVector as RAG to store user documents and industry knowledge documents after vectorization.
Test the entire agent process locally to confirm normal operation, then configure and deploy to Agentcore Runtime through Docker. Next, use Next.js to build a Chinese front-end UI, including user and administrator interfaces, and login authentication.
Set up IAM roles to access all AWS services, including Bedrock, AgentCore, Database Data API, Secret Manager, S3
Store all test scripts and documentation in the relevant directory.
Use real AWS services rather than simulated functionality.
Credential: Use the local credential “xxx” in the development environment, and the production environment can be switched to a role
Refer to Kiro Power to build AgentCore & Administer Agent to deploy according to best practices. This scenario is simple; don't use Agentcore Gateway.

            # Use Amazon Bedrock for comprehensive content analysis
            prompt = f"""
            You are an expert allergist. Analyze this allergy test content and provide accurate medical assessment.
            CONTENT: {content}
            CRITICAL INSTRUCTIONS:
            1. IGNORE any "Grade" or "级" information in the content - it's often incorrect
            2. Focus ONLY on the numerical values and units (IU/ml, KUA/L)
            3. For IU/ml units with 0-0.35 reference range:
               - <0.35 = Normal/Negative (Grade 0)
               - 0.35-3.5 = Low positive (Grade 1-2)  
               - 3.5-17.5 = Moderate positive (Grade 3)
               - >17.5 = High positive (Grade 4-5)
            4. Calculate the correct grade based on the value, not what's written
            5. Be specific about which allergens are concerning
            Format:
            ## Analysis Result
            [State if this contains actual allergy test results]
            ## Key Findings
            For each allergen: Name | Value | Correct Grade | Severity
            Example: Cockroach (蟑螂) | 18.887 IU/ml | Grade 5 (High) | Significant allergy requiring avoidance
            ## Medical Recommendations  
            [Specific recommendations based on actual severity levels]
            """
            response = self.bedrock_client.invoke_model(
                modelId='us.amazon.nova-pro-v1:0',
                body=json.dumps({
                    "messages": [{"role": "user", "content": [{"text": prompt}]}],
                    "inferenceConfig": {
                        "maxTokens": 1000,
                        "temperature": 0.2
                    }
                })
            )
            result = json.loads(response['body'].read())
            analysis = result.get('output', {}).get('message', {}).get('content', [])
            if analysis and isinstance(analysis, list) and len(analysis) > 0:
                analysis_text = analysis[0].get('text', 'Analysis completed')
            else:
                analysis_text = 'Analysis completed'
            logger.info("AI analysis completed successfully")
            return analysis_text, severity_score, True