DEV Community: Phạm Nguyễn Hải Anh

From Paperwork Mountains to Digital Freedom: Building an IDP Solution with Kiro

Phạm Nguyễn Hải Anh — Tue, 06 Jan 2026 14:58:45 +0000

Challenge: Office Staff Drowning in Paperwork

Every morning, Mai arrives at the government office where she works. Her desk is already piled high with paper documents - citizen applications, official reports, meeting minutes, and forms that need to be digitized.

Like thousands of office workers, Mai faces an exhausting daily routine:

💢Type for hours: Manually transcribing each document into Word
💢 Hunt for errors: Reviewing for typos and formatting mistakes
😫 Work overtime: Staying late to finish the backlog
😫 Feel exhausted: Repeating the same tedious task every single day

A single 5-page official document takes 30-45 minutes to transcribe. With dozens arriving daily, Mai is overwhelmed.

What if there was a better way?

The Vision: AI-Powered Document Processing

I wanted to build a solution where office staff could:

Take photos with their smartphone camera
Wait 30 seconds while AI processes them
Download perfectly formatted Word documents
Done! Ready to review and distribute

But I had a problem: I didn't know where to start.

How do I use AWS Bedrock for OCR?
How do I create properly formatted Word documents?
How do I preserve Vietnamese document headers?
How do I build a web interface?
How do I deploy on AWS?

That's when I turned to Kiro — my AI coding assistant.

Building with Kiro: The Journey

Step 1: The Initial Request

I started with a simple question to Kiro:

Me: "Given the AWS Bedrock Converse API and Claude Sonnet 4, build an AI solution to OCR images from a folder and convert them to Word DOCX files. Prefer Python. Search the internet for references."

Kiro immediately got to work:

Within minutes, Kiro had:

Fetched AWS Bedrock Converse API documentation
Researched python-docx library
Created complete project structure
Generated working code

Step 2: Fine-Tuning for Vietnamese Documents

The first version worked, but Vietnamese official documents have a special two-column header format that wasn't captured correctly.

My Request:

Me: "The phrase 'CỘNG HÒA XÃ HỘI CHỦ NGHĨA VIỆT NAM' should be in a table with two columns. Left column has organization info, right column has the country header and date."

Kiro's Response:

Kiro immediately:

Updated the OCR prompt to detect two-column headers
Modified create_docx.py to parse structured markup
Created borderless tables for proper formatting
Tested the changes automatically

# Kiro's clever solution - Structured OCR prompt
STRUCTURED_OCR_PROMPT = """
For Vietnamese official document headers with two columns, output as:
[HEADER_TABLE]
[LEFT]
organization line 1
organization line 2
Số: xx /TB-xxx
[/LEFT]
[RIGHT]
CỘNG HÒA XÃ HỘI CHỦ NGHĨA VIỆT NAM
Độc lập - Tự do - Hạnh phúc  
Tp. xxx, ngày xx tháng xx năm xxxx
[/RIGHT]
[/HEADER_TABLE]
"""

Result: Perfect two-column headers!

Step 3: Intelligent Multi-Page Grouping

I wanted images with similar names (doc-1.png, doc-2.png) to be combined into one Word file (doc.docx).

My Request:

Me: "If images have names with the same prefix but different numbers after a hyphen (e.g. tb-1, tb-2), group them into one DOCX file (e.g. named 'tb') with multiple pages."

Kiro's Implementation:

Kiro created a smart filename parser:

def get_prefix_and_page(filename: str) -> tuple:
    """
    Extract prefix and page number from filename.
    Examples:
        'invoice-1.png' -> ('invoice', 1)
        'report_2.jpg' -> ('report', 2)
        'standalone.png' -> ('standalone', 0)
    """
    stem = Path(filename).stem
    match = re.match(r'^(.+?)[-_](\d+)$', stem)

    if match:
        return match.group(1), int(match.group(2))
    return stem, 0

Result: Automatic multi-page document creation!

Step 4: Building the Web Interface

Manual CLI was working, but I needed a user-friendly web interface.

My Request:

Me: "Deploy a website that accepts image uploads, stores them in a S3 bucket, processes with Bedrock, outputs DOCX files, and provides download links."

Kiro's Response:

Within minutes, Kiro built:

Complete Flask web application
Drag & drop upload interface
S3 integration for storage
Session management for multi-user support
Download functionality with presigned URLs
HTML templates

@app.route('/upload', methods=['POST'])
def upload_files():
    """Handle file upload and processing"""
    files = request.files.getlist('files')
    session_id = str(uuid.uuid4())[:8]

    # Upload to S3
    for file in files:
        s3_key = f"images/{session_id}/{filename}"
        s3_client.upload_file(local_path, S3_BUCKET, s3_key)

        # OCR with Bedrock
        text = ocr_image_with_bedrock(local_path)
        ocr_results[filename] = text

    # Create grouped DOCX files
    create_grouped_documents(ocr_results)

Step 5: UI/UX Enhancement

The first UI worked but looked basic. I wanted something modern.

My Request:

Me: "The dashboard icons and colors look unacceptable. Search for modern color schemes and upgrade the UI."

Kiro transformed the interface with:

Modern dark theme with purple/blue gradients
Glassmorphism effects on cards
Animated background patterns
Mobile-responsive design
Success animations for feedback

/* Kiro's modern design system */
:root {
    --primary: #6366f1;
    --secondary: #0ea5e9;
    --accent: #8b5cf6;
    --gradient: linear-gradient(135deg, #6366f1 0%, #8b5cf6 50%, #0ea5e9 100%);
}

Result: Beautiful professional interface!

You can upload 2 image files with naming convention such as - and click Convert to DOCX.

It will take a while, around 1 minute to complete.

Demo

Please watch this demo at https://haianh-sing.s3.ap-southeast-1.amazonaws.com/2026-01-06+21-56-16.mp4.

What We Built Together

After working with Kiro for just 1 hour, we had a complete, production-ready Intelligent Document Processing platform that would have taken days to build manually.

The Power of AI-Assisted Development

Features Kiro Built

AI-Powered OCR: Claude Sonnet 4 with 95%+ accuracy
Mobile-First: Works with any smartphone camera
Vietnamese Support: Preserves official document formatting
Multi-Page: Automatic grouping by filename
Web Interface: Beautiful, responsive dark theme design
Cloud-Native: AWS S3, Bedrock, EC2 Graviton (ARM64)
Secure: IAM roles with least-privilege access
Cost-Effective: $0.003 per page
Production-Ready: Deployed to AWS with monitoring

Getting Started: Deploy Your Own System

Prerequisites

AWS Account Setup:

AWS Account with Bedrock access in us-west-2
Enable Claude Sonnet 4 model in Bedrock console
Create IAM user with admin access (for initial setup)

Local Development:

Python 3.9 or higher installed
AWS CLI configured (aws configure)
Git installed

Quick Start (5 Minutes)

Deployment on EC2

Step 1: Create IAM Role

# File iam-trust-policy.json containing trust policy
{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Sid": "S3BucketAccess",
            "Effect": "Allow",
            "Action": [
                "s3:CreateBucket",
                "s3:PutObject",
                "s3:GetObject",
                "s3:ListBucket",
                "s3:DeleteObject",
                "s3:HeadBucket"
            ],
            "Resource": [
                "arn:aws:s3:::ocr-to-docx",
                "arn:aws:s3:::ocr-to-docx/*"
            ]
        },
        {
            "Sid": "BedrockInvoke",
            "Effect": "Allow",
            "Action": [
                "bedrock:InvokeModel"
            ],
            "Resource": "*"
        }
    ]
}

# Create role with trust policy
aws iam create-role \
    --role-name Image2Docx-EC2-Role \
    --assume-role-policy-document file://iam-trust-policy.json

# Attach permissions policy
aws iam put-role-policy \
    --role-name Image2Docx-EC2-Role \
    --policy-name Image2Docx-Policy \
    --policy-document file://iam-policy.json

# Create instance profile
aws iam create-instance-profile \
    --instance-profile-name Image2Docx-EC2-Profile

# Add role to profile
aws iam add-role-to-instance-profile \
    --instance-profile-name Image2Docx-EC2-Profile \
    --role-name Image2Docx-EC2-Role

Step 2: Launch EC2 Instance

# Launch Graviton instance (ARM64 - cost efficient)
aws ec2 run-instances \
    --image-id ami-xxxxxxxxx \  # Amazon Linux 2023 ARM64
    --instance-type t4g.micro \
    --key-name your-key-pair \
    --security-group-ids sg-xxxxxxxxx \
    --iam-instance-profile Name=Image2Docx-EC2-Profile \
    --tag-specifications 'ResourceType=instance,Tags=[{Key=Name,Value=Image2Docx-Server}]'

Step 3: Configure Security Group

# Allow inbound HTTP on port 8080
aws ec2 authorize-security-group-ingress \
    --group-id sg-xxxxxxxxx \
    --protocol tcp \
    --port 8080 \
    --cidr 0.0.0.0/0

# Allow SSH for administration
aws ec2 authorize-security-group-ingress \
    --group-id sg-xxxxxxxxx \
    --protocol tcp \
    --port 22 \
    --cidr your-ip-address/32

Step 4: Deploy Application

# SSH to instance
ssh -i "your-key.pem" ec2-user@<EC2-PUBLIC-IP>

# Update system
sudo yum update -y

# Install dependencies
sudo yum install -y git python3-pip

# Clone repository
git clone https://github.com/PNg-HA/Image2Docx.git
cd Image2Docx

# Install Python packages
pip3 install -r requirements.txt

# Run application in background
nohup python3 app.py > app.log 2>&1 &

Step 5: Access Your Application

Open browser and navigate to:

http://<EC2-PUBLIC-IP>:8080

Success! Your intelligent documentation platform is live.

Conclusion: From Vision to Reality in 1 Hour with Kiro

We started with a simple question: "Can we help office staff escape the paperwork trap?"

The answer is a resounding YES. But what's even more remarkable is HOW we did it.

This platform is my contribution to eliminating paperwork drudgery and freeing office workers. But more importantly, this project proves that anyone with vision and AI assistance can build transformative solutions.

What will you build with Kiro?

Elevating Product Visualization with Amazon Nova Canvas on Bedrock

Phạm Nguyễn Hải Anh — Mon, 19 May 2025 06:37:23 +0000

Amazon Nova Canvas is a powerful image generation service available through AWS Bedrock, enabling developers and creatives to generate, edit, and manipulate product visuals using state-of-the-art AI models. In this guide, we focus on product visualization—how Nova Canvas empowers businesses to create high-quality, customized product images for catalogs, marketing materials, and online storefronts.

1. Supported Task Types & Parameters

Amazon Nova Canvas supports a variety of image generation and editing tasks, each customizable via specific parameters:

Task Type	Parameter Field	Category	Description
TEXT_IMAGE (Text only)	`textToImageParams`	Generation	Generates images from descriptive text prompts.
TEXT_IMAGE (Image conditioning)	`textToImageParams`	Generation	Combines a reference image with text to guide layout.
COLOR_GUIDED_GENERATION	`colorGuidedGenerationParams`	Generation	Guides generation with specified hex colors and optional image.
IMAGE_VARIATION	`imageVariationParams`	Generation	Creates stylized variations of input images.
INPAINTING	`inPaintingParams`	Editing	Modifies content inside a masked region.
OUTPAINTING	`outPaintingParams`	Editing	Extends or changes areas outside a masked region.
BACKGROUND_REMOVAL	`backgroundRemovalParams`	Editing	Removes image background to create transparency.

2. Input and Output Specs for Product Images

Input Images: Base64-encoded PNG or JPEG
Accepted Formats:
- PNG (supports alpha channel, but transparency not always allowed)
- JPEG (recommended at 100% quality)
Masks: Must be pure black (masked area) and pure white (non-masked). No grayscale or color pixels.
Supported Resolutions:
- From 320 to 4096 pixels per side
- Aspect ratio between 1:4 and 4:1
- Maximum total pixels: 4.19 million (e.g., 2048x2048)
Output Image Dimensions: Must be divisible by 16

3. Common Configuration Parameters for Consistent Product Renders

Parameter	Description	Default
`width`, `height`	Output image size	1024 x 1024
`quality`	Image quality, `"standard"` or `"premium"`	`"standard"`
`cfgScale`	Prompt adherence strength (1.1–10)	6.5
`numberOfImages`	Number of images to generate (1–5)	1
`seed`	Random generation control for reproducibility	12

4. Example: Creating a Product Render from Text

{
  "taskType": "TEXT_IMAGE",
  "textToImageParams": {
    "text": "A futuristic city skyline at sunset",
    "negativeText": "No people, no cars"
  },
  "imageGenerationConfig": {
    "width": 1024,
    "height": 1024,
    "quality": "standard",
    "cfgScale": 6.5,
    "seed": 12,
    "numberOfImages": 1
  }
}

Note: Avoid negations like "no" or "without" in text and negativeText; instead, explicitly specify what to exclude in negativeText.

Input

Prompt: A high-resolution studio photo of a pair of stylish white leather sneakers placed on a clean light gray background. The shoes are angled slightly to show both the side and top view. Soft diffused lighting, no shadows or background distractions. Ideal for an online product catalog.

body = json.dumps({
    "taskType": "TEXT_IMAGE",
    "textToImageParams": {
        "text": prompt
    },
    "imageGenerationConfig": {
        "numberOfImages": 1,
        "height": 1024,
        "width": 1024,
        "cfgScale": 8.0,
        "seed": 0
    }
})

Ouput

5. Image Conditioning with Reference Images

Amazon Nova supports image generation guided by a reference image with control modes such as:

CANNY_EDGE – preserves edge outlines
SEGMENTATION – preserves content shapes

Key parameters:

conditionImage: Base64-encoded guiding image
controlMode: "CANNY_EDGE" or "SEGMENTATION"
controlStrength: Degree to which generated image follows guide (0 to 1)

Input

prompt = (
    "Add a small black Nike logo on the side of each white sneaker. "
    "Keep the shoes clean, white, and minimalistic, in a professional studio setting. "
    "Ensure the lighting and shadows remain soft and realistic. "
    "Maintain the same shoe position and clean background."
)
negativeText = "blurry, distorted logo, cartoon, low resolution, watermark, logo on wrong location, off-center"
body = json.dumps(
    {
        "taskType": "TEXT_IMAGE",
        "textToImageParams": {
            "text": prompt,
            "negativeText": negativeText,
            "conditionImage": input_image,
            "controlMode": "CANNY_EDGE",
        },
        "imageGenerationConfig": {
            "height": 1024,
            "width": 1024,
            "quality": "premium",
            "cfgScale": 8.0,
            "seed": 12,
            "numberOfImages": 1,
        },
    }
)

Ouput

Input

body = json.dumps(
    {
        "taskType": "TEXT_IMAGE",
        "textToImageParams": {
            "text": prompt,
            "negativeText": negativeText,
            "conditionImage": input_image,
            "controlMode": "SEGMENTATION",
        },
        "imageGenerationConfig": {
            "height": 1024,
            "width": 1024,
            "quality": "premium",
            "cfgScale": 8.0,
            "seed": 12,
            "numberOfImages": 1,
        },
    }
)

Ouput

6. Apply Brand Colors with Color-Guided Generation

Specify up to 10 hex color codes to influence the color palette of generated images. This can be combined with a style reference image for artistic control.

Input

body = json.dumps(
    {
        "taskType": "COLOR_GUIDED_GENERATION",
        "colorGuidedGenerationParams": {
            "text": "a stylish pair of pink sneakers, same shape and angle as the reference, realistic lighting, minimalistic background",
            "negativeText": "white shoes, overexposed, harsh lighting, low resolution, unrealistic shadows, cluttered background, watermark",
            "referenceImage": input_image,
            "colors": [
                "#ffc0cb",  # Pink
                "#ffb6c1",  # LightPink
                "#f4cccc",  # PalePink
                "#000000",  # (for some depth/shadow)
            ],
        },
        "imageGenerationConfig": {
            "numberOfImages": 1,
            "height": 1024,
            "width": 1024,
            "cfgScale": 8.0,
        },
    }
)

Ouput

7. Generate Variations of Existing Product Photos

Generate stylized versions of input images by adjusting the similarityStrength parameter, which controls how much variation is applied relative to the original image.

Input

body = json.dumps(
    {
        "taskType": "IMAGE_VARIATION",
        "imageVariationParams": {
            "text": "A more modern version of this sunscreen product tube, same layout, 3D render, clean white background",
            "negativeText": "blurry text, distorted label, different shape, wrong lighting, added elements, different background",
            "images": images,
            "similarityStrength": 0.5,  # Range: 0.2 to 1.0
        },
        "imageGenerationConfig": {
            "numberOfImages": 2,
            "height": 1024,
            "width": 1024,
            "cfgScale": 9.5,
        },
    }
)

Ouput

8. Use Inpainting/Outpainting to Clean or Extend Product Images

Inpainting: Edit specific masked regions inside an image based on a mask or natural language description.

body = json.dumps(
    {
        "taskType": "INPAINTING",
        "inPaintingParams": {
            "image": string (Base64 encoded image),
            "maskPrompt": string,
            "maskImage": string (Base64 encoded image),
            "text": string,
            "negativeText": string
        },
        "imageGenerationConfig": {
            "numberOfImages": int,
            "quality": "standard" | "premium",
            "cfgScale": float,
            "seed": int
        }
    }
)

Input

Output

Outpainting: Extend image content beyond its current borders, with two modes:
- "DEFAULT" (blended, natural extension)
- "PRECISE" (strict, exact extension)

body = json.dumps(
    {
        "taskType": "OUTPAINTING",
        "outPaintingParams": {
            "image": string (Base64 encoded image),
            "maskPrompt": string,
            "maskImage": string (Base64 encoded image),
            "outPaintingMode": "DEFAULT" | "PRECISE",
            "text": string,
            "negativeText": string
        },
        "imageGenerationConfig": {
            "numberOfImages": int,
            "quality": "standard" | "premium"
            "cfgScale": float,
            "seed": int
        }
    }
)

Input

Output

9. Clean Cutouts with Background Removal

Amazon Nova can isolate foreground objects by removing backgrounds, producing PNG outputs with full transparency. This is ideal for compositing workflows.

Input

body = json.dumps(
    {
        "taskType": "BACKGROUND_REMOVAL",
        "backgroundRemovalParams": {
            "image": input_image
        }
    }
)

Ouput

10. Error Handling

Common error types include:

ValidationException: Invalid input format or unsupported parameters
RAI Input Deflection: Input blocked by responsible AI content filters
RAI Output Deflection: Generated image blocked due to moderation policies

Conclusion

Amazon Nova Canvas offers e-commerce teams, designers, and marketers a transformative tool for creating high-quality product visuals—quickly, repeatedly, and at scale. Whether launching new SKUs, running A/B tests on creatives, or enriching catalog listings, Nova Canvas provides unparalleled creative control.

What’s Next?

Explore Amazon Bedrock documentation for model updates.
Try integrating Nova Canvas into your creative or e-commerce workflows.
Stay tuned for more features like image-to-image translation and control-net guided generation.

References

AI HR Assistant with Amazon Bedrock Agent

Phạm Nguyễn Hải Anh — Mon, 19 May 2025 04:46:40 +0000

Introduction

As organizations grow and evolve, so do the demands on Human Resources. Internal teams often face repetitive, time-consuming tasks—like answering common policy questions, processing leave requests, or managing onboarding queries—that can slow down productivity and strain HR capacity. An AI-powered HR assistant offers a smart, scalable solution to this challenge. This not only reduces the administrative burden on HR staff but also enhances the employee experience through quick resolution of queries and more personalized support.

This blog helps you to create an AI HR assistant that can give you internal regulations, automate the Time Leave request by using Amazon Bedrock Nova Pro model.

Architecture

Prerequisites

AWS credential grants Bedrock, Lambda, S3, Athena, Glue, OpenSearch permissions
Linux environment

Steps

git clone https://github.com/aws-samples/amazon-bedrock-samples.git
cd amazon-bedrock-samples/tree/main/agents-and-function-calling/bedrock-agents/use-case-examples/hr-assistant/shell

Use the suitable model (in this blog I use Nova Pro) by editing file cfn /hr-resources.yml, change amazon.titan-text-premier-v1:0 to amazon.nova-pro-v1:0

Run the script:
source ./create-hr-resources.sh

Check mail:

Subscribe topic:

Once the deployment is finished. You can use the Bedrock Agent Playground:

Or you can create a web frontend with streamlit. First install streamlit:
pip install -r agents-and-function-calling/bedrock-agents/use-case-examples/hr-assistant/streamlit/requirements.txt

then cd hr-assistant/streamlit and run streamlit run agent_streamlit.py

Check history query database employee trong Athena:

Troubleshooting

Bug 1:

Bug: User: arn:aws:iam::your-account-id:user/user-name is not authorized to perform: lambda:GetLayerVersion on resource: arn:aws:lambda:us-east-1:017000801446:layer:AWSLambdaPowertoolsPythonV2:68 because no resource-based policy allows the lambda:GetLayerVersion action (Service: Lambda, Status Code: 403, ..., HandlerErrorCode: AccessDenied)
Solution: Find the line containing arn:aws:lambda:us-east-1:017000801446:layer:AWSLambdaPowertoolsPythonV2:68 in file hr-resources.yml and change the region to where you deploy.

Redeploy and bug

Bug: The script create-hr-resources.sh exits 1 and exit the terminal

Explanation: The script is created for 1 time usage as creating a database and a table. Hence when you redeploy in the same region, make sure to delete all created resources, including the CloudFormation stack. To remove the database in Athena, first delete all data in the table:

Delete table in Amazon Glue:

then run this command:

aws athena start-query-execution --query-string "DROP DATABASE employee" --result-configuration "OutputLocation=s3://<your-accound-id>--hr-resources"

You can check the status of the query in the Athena Console:

If Status Failed, ensure database has no data.

Bug 3:

Error: Runtime.ImportModuleError: Unable to import module 'lambda.index': No module named 'requests' Traceback (most recent call last)

Solution: replace from botocore.vendored import requests (ref: https://stackoverflow.com/questions/48912253/aws-lambda-unable-to-import-module-lambda-function-no-module-named-requests)

Conclusion

Integrating an AI-powered HR assistant using Amazon Bedrock streamlines internal HR operations by automating repetitive tasks and providing instant, accurate responses to employee queries. This guide demonstrated how to deploy the solution end-to-end—from setting up resources to building a user-friendly Streamlit interface—enabling HR teams to focus on strategic initiatives while improving the employee experience. By leveraging the power of generative AI and scalable AWS services, organizations can create a more efficient, responsive, and modern HR function.

Boost Your English Reflexes with Amazon Nova Sonic

Phạm Nguyễn Hải Anh — Sat, 17 May 2025 19:04:33 +0000

Scenario

Many people want to improve their English speaking reflexes simply to communicate effectively at work, not to master academic grammar or pass expensive language exams. Traditional language courses or private tutors can be costly and time-consuming, creating a barrier for those who just need practical, job-related English skills. AI-powered tools offer a more affordable and flexible alternative, allowing learners to practice real-life conversations anytime, receive instant feedback, and build confidence in speaking. This makes AI a smart choice for professionals who want fast, accessible, and focused language support.

In this blog, we’ll show you how to build your own AI-powered English tutor—designed specifically for everyday professionals who just want to speak up and be heard.

Workflow

Workflow:

Frontend (React Web Client): Provides the user interface and communicates with the backend via WebSocket for real-time interaction.
Backend (Python WebSocket Server): Manages client sessions and relays data between the frontend and the AI model.
Streaming & AI Integration: Streams audio/text to Amazon Bedrock Nova Sonic and returns real-time AI responses to the frontend.

Prerequisites

Install dependencies

You will need:

Python v3.12+ and pip
Node v14+ and NPM
AWS boto3
AWS credentials that granted Bedrock access

Run the following codes to install pip, AWS CLI for ARM (latest version), NPM (10.9.2) and Node (22.15.1) if you use Ubuntu:

sudo apt-get update
sudo apt-get upgrade

# Install pip
sudo apt install python3-pip

# install aws cli latest version
sudo apt install unzip
curl "https://awscli.amazonaws.com/awscli-exe-linux-aarch64.zip" -o "awscliv2.zip"
unzip awscliv2.zip
sudo ./aws/install

# Download and install nvm:
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.3/install.sh | bash
# in lieu of restarting the shell
\. "$HOME/.nvm/nvm.sh"
# Download and install Node.js:
nvm install 22
# Verify the Node.js version:
node -v # Should print "v22.15.1".
nvm current # Should print "v22.15.1".
# Verify npm version:
npm -v # Should print "10.9.2".

Installation

Currently, the project just works at localhost.
Clone the repo:

git clone https://github.com/PNg-HA/BoostEnglishSpeakingReflexes_NovaSonic.git
cd BoostEnglishSpeakingReflexes_NovaSonic

Start the Server

Create a virtual envirionment with venv module

cd python-server
python3 -m venv .venv
pip install -r requirements.txt

then set the environment variables.

Windows:

$env:AWS_ACCESS_KEY_ID="your-key"
$env:AWS_SECRET_ACCESS_KEY="your-secret-key"
$env:AWS_DEFAULT_REGION="us-east-1"
$env:HOST="localhost"
$env:WS_PORT=8081
$env:HEALTH_PORT=8082
$env:AWS_PROFILE='default'

Linux:

export AWS_ACCESS_KEY_ID="your-key"
export AWS_SECRET_ACCESS_KEY="your-secret-key"
export AWS_DEFAULT_REGION="us-east-1"
export HOST="localhost"
export WS_PORT=8081
export HEALTH_PORT=8082
export AWS_PROFILE='default'

Run the server:
python3 server.py

Note: You must leave this terminal open to run the server. For the later steps, open a new terminal.

Start frontend

cd BoostEnglishSpeakingReflexes_NovaSonic/react-client
npm install

Set the environment variables:
Linux:
export REACT_APP_WEBSOCKET_URL='ws://localhost:8081'
Windows:
$env:REACT_APP_WEBSOCKET_URL = "ws://localhost:8081"

Start the frontend:
npm start

Wait for seconds to load

One website will be opened automatically

You can set up the scenario through the prompt by going to Setting button:

Demo

https://haianh.s3.us-east-1.amazonaws.com/AIEnglishTutor.mp4

Conclusion

By following this guide, you now have a functional AI-powered English speaking assistant running locally — tailored for professionals who want to improve their communication skills quickly and practically. This solution offers a low-cost, customizable alternative to traditional learning methods by leveraging modern AI models and cloud infrastructure. Whether you're preparing for daily meetings, job interviews, or cross-border collaboration, this tool empowers you to practice speaking English in realistic scenarios, on your own schedule, and with immediate feedback. It's not just a tech project — it's a step toward more confident, fluent, and effective communication in the workplace.

Optimize E-Commerce with AI Agent Using Amazon Nova Models

Phạm Nguyễn Hải Anh — Fri, 09 May 2025 12:43:23 +0000

In today's digital age—especially with strong government support for digital transformation—building an e-commerce website is easier than ever. However, making it attractive, user-friendly, and sales-driven still requires strategic optimization.
To solve this, we built an AI-powered Agent that assists business owners in managing and improving their e-commerce websites. This intelligent assistant detects design/content issues, suggests improvements, and enhances the overall site experience to retain customers and boost sales.

Use Case Overview

In developing our AI Agent to support e-commerce, we focused on addressing the essential needs of business owners:

Deep analysis of critical pages such as the Homepage, Product Listings, and Cart.
Optimization recommendations for layout, content, and SEO to enhance user experience and boost conversion rates.
Automated content generation for product descriptions, sidebars, and other key areas that require engaging copy.
Customer email drafting support to strengthen engagement and build customer loyalty.

All these tasks are executed directly within the browser through an intuitive extension. Users can easily review, receive suggestions, and apply improvements with just a few clicks—without needing any technical expertise.

Why Amazon Nova Models?

After a thorough process of testing, evaluating, and comparing different AI models based on real-world requirements, I identified three potential options for deploying my AI Agent.

However, with a strong focus on cost optimization and leveraging cloud environments as the primary platform, I decided to choose Amazon Nova as the core model for my AI Agent.

Nova Lite: Used for tasks that require high speed and low cost, such as quickly analyzing page layouts, identifying basic issues, and providing instant improvement suggestions.
Nova Pro: Ideal for tasks that demand high-quality content and deeper contextual understanding, such as generating product descriptions, drafting customer engagement emails, or recommending personalized user experiences.

By flexibly combining Nova Lite and Nova Pro, I can perfectly balance speed, cost, and output quality, effectively meeting the optimization needs of e-commerce websites.

How We Utilized Amazon Nova (Technical Execution)

In our latest project, we built a robust architecture that maximizes the use of Amazon Bedrock and the Nova model line to transform the way we interact with e-commerce websites. Let’s explore the technical steps and how we designed the system for optimal performance and scalability.
Currently, we deep dive in this Architecture.

Preparation: Grant Access to Nova Lite and Nova Pro Models

Before we start building the system, the first and most crucial step is:

Registering for access to Nova Lite and Nova Pro on Amazon Bedrock.
Ensuring that IAM accounts, Agent policies, and the API Gateway have sufficient permissions to call the Nova models.

This ensures the system can directly call the Nova model when generating content and is ready to integrate additional AI models in the future if needed.

Building the Process with Bedrock Agent

We designed a custom Bedrock Agent workflow to seamlessly coordinate all the steps in the pipeline. Here’s how it works:

Create an S3 Bucket to Store Crawled Data (HTML, Screenshot). This bucket will store the HTML content, text extractions, and screenshots from crawled websites.

Create a Lambda Function: Website Crawler

import requests
from bs4 import BeautifulSoup
import boto3
import json
import uuid
import base64
from selenium import webdriver
from selenium.webdriver.chrome.options import Options
import io
from PIL import Image

s3 = boto3.client('s3')

def lambda_handler(event, context):
    print("Received event:", event)

    url = event.get('url')
    if not url:
        return {"statusCode": 400, "body": "URL is required."}

    bucket_name = "bedrock-agent-webcrawler-data"  # Replace with your actual bucket name
    file_id = str(uuid.uuid4())

    try:
        # Fetch HTML content
        response = requests.get(url)
        html_content = response.text

        # Save HTML to S3
        html_key = f"crawl/{file_id}/content.html"
        s3.put_object(
            Bucket=bucket_name,
            Key=html_key,
            Body=html_content,
            ContentType='text/html'
        )

        # Parse and extract text from HTML
        soup = BeautifulSoup(html_content, 'html.parser')
        text_content = soup.get_text(separator='\n')

        # Save extracted text to S3
        text_key = f"crawl/{file_id}/content.txt"
        s3.put_object(
            Bucket=bucket_name,
            Key=text_key,
            Body=text_content,
            ContentType='text/plain'
        )

        return {
            "statusCode": 200,
            "body": {
                "message": "Website crawled and saved successfully.",
                "file_id": file_id,
                "html_path": f"s3://{bucket_name}/{html_key}",
                "text_path": f"s3://{bucket_name}/{text_key}",
                "url": url
            }
        }
    except Exception as e:
        print(f"Error: {str(e)}")
        return {"statusCode": 500, "body": str(e)}

Set Permissions, Click "Add permissions" → "Attach policies". Search for and select "AmazonS3FullAccess". Then click "Add permissions".

This permission allows the Lambda function to upload data to your S3 bucket.

Create a Lambda Function: Content Pre-Processor

import boto3
import json
from bs4 import BeautifulSoup
import re

s3 = boto3.client('s3')

def clean_text(text):
    text = re.sub(r'\s+', ' ', text)
    return text.strip()

def lambda_handler(event, context):
    print("Received event:", event)

    bucket = event.get('bucket', 'bedrock-agent-webcrawler-data') # Replace with your actual bucket name
    html_key = event.get('html_path', '').split('/')[-1]
    file_id = event.get('file_id', '')

    if not file_id:
        return {"statusCode": 400, "body": "Missing file_id"}

    html_key = f"crawl/{file_id}/content.html"

    try:
        response = s3.get_object(Bucket=bucket, Key=html_key)
        html_content = response['Body'].read().decode('utf-8')

        # Parse HTML
        soup = BeautifulSoup(html_content, 'html.parser')

        text = soup.get_text()
        cleaned_text = clean_text(text)

        processed_content = {
            "original_url": event.get('url', 'Unknown'),
            "title": soup.title.string if soup.title else "No title",
            "content": cleaned_text[:100000]  # Giới hạn độ dài
        }

        processed_key = f"processed/{file_id}/content.json"
        s3.put_object(
            Bucket=bucket,
            Key=processed_key,
            Body=json.dumps(processed_content),
            ContentType='application/json'
        )

        return {
            "statusCode": 200,
            "body": {
                "message": "Content processed successfully",
                "processed_file": f"s3://{bucket}/{processed_key}",
                "file_id": file_id
            }
        }
    except Exception as e:
        print(f"Error: {str(e)}")
        return {"statusCode": 500, "body": str(e)}

Create a DynamoDB Table

Enable Time to Live (TTL) to automatically expire items

Create Free Chat Lambda Function

import boto3
import json
import hashlib
import time

dynamodb = boto3.resource('dynamodb')
table = dynamodb.Table('BedrockAgentCache')
bedrock_agent = boto3.client('bedrock-agent-runtime')

def lambda_handler(event, context):
    print("Received event:", event)

    query = event.get('query')
    if not query:
        return {"statusCode": 400, "body": "Query is required"}

    query_id = hashlib.md5(query.encode()).hexdigest()

    try:
        response = table.get_item(Key={'QueryId': query_id})
        if 'Item' in response:
            return {
                "statusCode": 200,
                "body": {
                    "result": response['Item']['Result'],
                    "source": "cache"
                }
            }
    except Exception as e:
        print(f"Error checking cache: {str(e)}")

    try:
        agent_id = "your-agent-id"  # Thay bằng ID của agent
        agent_alias_id = "your-agent-alias-id"  # Thay bằng alias ID

        response = bedrock_agent.invoke_agent(
            agentId=agent_id,
            agentAliasId=agent_alias_id,
            sessionId=f"session-{int(time.time())}",
            inputText=query
        )

        result = ""
        for event in response.get('completion', []):
            if 'chunk' in event:
                result += event['chunk']['bytes'].decode('utf-8')

        table.put_item(Item={
            'QueryId': query_id,
            'Query': query,
            'Result': result,
            'TTL': int(time.time()) + 86400  # 24 giờ
        })

        return {
            "statusCode": 200,
            "body": {
                "result": result,
                "source": "bedrock"
            }
        }
    except Exception as e:
        print(f"Error calling Bedrock Agent: {str(e)}")
        return {"statusCode": 500, "body": str(e)}

In the AWS Lambda console, click "Add permissions" > "Attach policies".
Search for and select "AmazonDynamoDBFullAccess" and "AmazonBedrockFullAccess", then click "Add permissions".

Create Bedrock Agent

Prompt: “You are an assistant specialized in answering questions based on content collected from websites.
When given a URL, you must access the site, crawl and analyze its content, and answer questions strictly based on the actual data retrieved.
You must adhere closely to the collected content and are not allowed to invent or assume information beyond what is available.”

Create Action Group

Enter the following OpenAPI schema:

{
  "openapi": "3.0.0",
  "info": {
    "title": "Website Crawler API",
    "version": "1.0.0"
  },
  "paths": {
    "/crawl": {
      "post": {
        "summary": "Crawl a website",
        "operationId": "crawlWebsite",
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "type": "object",
                "properties": {
                  "url": {
                    "type": "string",
                    "description": "URL of the website to crawl"
                  }
                },
                "required": ["url"]
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Successful operation",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "message": {
                      "type": "string"
                    },
                    "file_id": {
                      "type": "string"
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
}

Update Free Chat Lambda Function with Agent ID

Go back to the Lambda console.
Open the "BedrockAgentChatFunction".
Update the agent_id and agent_alias_id in the code with the information from the agent you just created.
Click "Deploy" to save the changes.

Test Agent

Enter the following test prompt: "Crawl the website https://example.com and tell me what it's about"

Result

Through the clever integration of Bedrock Agent, custom Lambda Functions, the Nova model, and serverless AWS services like S3 and DynamoDB, we have built a flexible, cost-effective, and scalable architecture to serve personalized content creation at scale.

This system is not only a technical achievement in cloud computing but also a prime example of how smart automation can enhance customer experiences and drive business growth in the e-commerce industry.
And this is just the beginning of the journey!

AI retailer assistant with Amazon Bedrock agent

Phạm Nguyễn Hải Anh — Fri, 09 May 2025 07:35:33 +0000

Scenario

A shoe website wants a virtual retailer that can chat with customers, find suitable products in the inventory and add them to the cart.

Architecture

The virtual retailer assistant is built by using Amazon Bedrock Agent Nova Pro.

Here is the workflow:

A customer asks the retailer agent for a specific type of product, with some requirements including colors, prices, purposes. 2-3-4. Referred to the OpenAPI schema and based on the scenario, the agent invokes a Lambda function to query to the inventory table to list all products.
The agent infers from the response of the Lambda function, combines it with the customer's preferences, and recommends suitable products.

In case the customer choose product(s) from the response of the agent, the agent will add the product to the cart by invoking a different Lambda function to interact with the Cart table.

Prerequisites

The customer must enable access to Nova Pro in the specific AWS Region.

Steps

In this scope of demo, I create a SQLite file with 2 tables given above. If you want to create a SQLite database, you can download the SQLite Editor extension in VS Code.

Step 1. Setup table ShoeInventory and table OrderDetails in database named demo_csbot_db_2

The last column of the ShoeInventory table (S3Location) is for showing the images of the products.

Step 2. Create the OpenAPI schema

{
    "openapi": "3.0.0",
    "info": {
        "title": "Customer Service Bot API",
        "version": "1.0.0",
        "description": "Customer service APIs for a retail store selling shoes"
    },
    "paths": {
        "/place_order": {
            "get": {
                "summary": "Sub task to place an order on behalf of the customer",
                "description": "Place an order for the number of shoes by creating an Order record and updating inventory in the database",
                "operationId": "get_place_order",
                "parameters": [{
                    "name": "ShoeID",
                    "in": "query",
                    "description": "Shoe ID to place an order",
                    "required": true,
                    "schema": {
                        "type": "integer"
                    }
                },
                {
                    "name": "CustomerID",
                    "in": "query",
                    "description": "Customer ID to place an order",
                    "required": true,
                    "schema": {
                        "type": "integer"
                    }
                },
                {
                    "name": "NumberOfProducts",
                    "in": "query",
                    "description": "Number of shoes to order",
                    "required": true,
                    "schema": {
                        "type": "integer"
                    }
                }],
                "responses": {
                    "200": {
                        "description": "Order has been placed",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "type": "object",
                                    "properties": {
                                        "message": {
                                            "type": "string",
                                            "description": "Your order has been placed"
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        },
        "/check_inventory": {
            "get": {
                "summary": "Returns all details related to shoes, including inventory details",
                "description": "Checks inventory for shoes and returns all available information about available shoes, including shoe ID, shoe colors, inventory, best fit activity, style description, s3 location and price ",
                "operationId": "get_check_inventory",
                "responses": {
                    "200": {
                        "description": "Returns Shoe information",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "type": "object",
                                    "properties": {
                                        "ShoeID": {
                                            "type": "integer",
                                            "description": "This is the shoe ID for this shoe"
                                        },
                                            "BestFitActivity": {
                                            "type": "string",
                                            "description": "Best fit activity for this shoe"
                                        },
                                            "StyleDesc": {
                                            "type": "string",
                                            "description": "Detailed description of the shoe"
                                        },
                                            "ShoeColors": {
                                            "type": "string",
                                            "description": "The colors of this shoe"
                                        },
                                            "Price": {
                                            "type": "string",
                                            "description": "Price of this shoe"
                                        },
                                            "InvCount": {
                                            "type": "integer",
                                            "description": "Inventory count"
                                        },
                                            "Size": {
                                            "type": "integer",
                                            "description": "Inventory size"
                                        },
                                        "S3Location": {
                                            "type": "string",
                                            "description": "Image of the shoe"
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }    
}

Step 3. Create Lambda code, one function to query the ShoeInventory table and one function to add to the OrderDetail table. Also, give it the necessary permissions.

import json
import boto3
import sqlite3
from datetime import datetime
import random
import logging
import os

logger = logging.getLogger()
logger.setLevel(logging.INFO)

s3 = boto3.client('s3')
bucket = os.environ.get('BUCKET_NAME')  #Name of bucket with data file and OpenAPI file
db_name = 'demo_csbot_db_2.sqlite' #Location of data file in S3
local_db = '/tmp/csbot.db' #Location in Lambda /tmp folder where data file will be copied

#Download data file from S3
s3.download_file(bucket, db_name, local_db)

cursor = None
conn = None

#Initial data load and SQLite3 cursor creation 
def load_data():
    #load SQL Lite database from S3
    # create the db
    global conn
    conn = sqlite3.connect(local_db)
    cursor = conn.cursor()
    logger.info('Completed initial data load ')

    return cursor

#Function returns all customer info for a particular customerId
def return_customer_info(custName):
    query = 'SELECT customerId, customerName, Addr1, Addr2, City, State, Zipcode, PreferredActivity, ShoeSize, OtherInfo from CustomerInfo where customerName like "%' +  custName +'%"'
    cursor.execute(query)
    resp = cursor.fetchall()
    #adding column names to response values
    names = [description[0] for description in cursor.description]
    valDict = {}
    index = 0
    for name in names:
        valDict[name]=resp[0][index]
        index = index + 1
    logger.info('Customer Info retrieved', valDict)
    return valDict


#Function returns shoe inventory for a particular shoeid 
def return_shoe_inventory():
    query = 'SELECT ShoeID, BestFitActivity, StyleDesc, ShoeColors, Price, InvCount, Size, S3Location from ShoeInventory' 
    cursor.execute(query)
    resp = cursor.fetchall()
    print ("query: ", resp)

    #adding column names to response values
    names = [description[0] for description in cursor.description]
    valDict = []
    interimDict = {}
    index = 0
    for item in resp:
        for name in names:
            interimDict[name]=item[index]
            index = index + 1
        index = 0
        valDict.append(interimDict)
        interimDict={}
    logger.info('Shoe info retrieved')
    return valDict

def return_shoe_image_inventory():
    query = 'SELECT ShoeID, S3Location from ShoeInventory' 
    cursor.execute(query)
    resp = cursor.fetchall()
    print ("query: ", resp)
    #adding column names to response values
    names = [description[0] for description in cursor.description]
    valDict = []
    interimDict = {}
    index = 0
    for item in resp:
        for name in names:
            interimDict[name]=item[index]
            index = index + 1
        index = 0
        valDict.append(interimDict)
        interimDict={}
    logger.info('Shoe and image info retrieved')
    return valDict

#function places order -- reduces shoe inventory, updates order_details table --> all actions resulting from a shoe purchase  
def place_shoe_order(ssId, custId, InvCnt):
    global cursor
    global conn
    query = 'Update ShoeInventory set InvCount = InvCount - 1 where ShoeID = ' + str(ssId)
    ret = cursor.execute(query)

    today = datetime.today().strftime('%Y-%m-%d')
    query = 'INSERT INTO OrderDetails (orderdate, shoeId, CustomerId, InvCount) VALUES ("'+today+'",'+str(ssId)+','+ str(custId)+','+str(InvCnt)+')'
    ret = cursor.execute(query)
    conn.commit()

    #Writing updated db file to S3 and setting cursor to None to force reload of data
    s3.upload_file(local_db, bucket, db_name)
    cursor = None
    logger.info('Shoe order placed')
    return 1


def lambda_handler(event, context):
    responses = []
    global cursor
    if cursor == None:
        cursor = load_data()
    id = ''
    api_path = event['apiPath']
    logger.info('API Path')
    logger.info(api_path)

    if api_path == '/customer/{CustomerName}':
        parameters = event['parameters']
        for parameter in parameters:
            if parameter["name"] == "CustomerName":
                cName = parameter["value"]
        body = return_customer_info(cName)
    elif api_path == '/place_order':
        parameters = event['parameters']
        print ("place order parameters:", parameters)
        for parameter in parameters:
            if parameter["name"] == "ShoeID":
                id = parameter["value"]
            if parameter["name"] == "CustomerID":
                cid = parameter["value"]
            if parameter["name"] == "NumberOfProducts":
                numOfProd = parameter["value"]
        body = place_shoe_order(id, cid, numOfProd)
    elif api_path == '/check_inventory':
        body = return_shoe_inventory()
    elif api_path == '/check_image_inventory':
        body = return_shoe_image_inventory()
    else:
        body = {"{} is not a valid api, try another one.".format(api_path)}

    response_body = {
        'application/json': {
            'body': json.dumps(body)
        }
    }

    action_response = {
        'actionGroup': event['actionGroup'],
        'apiPath': event['apiPath'],
        'httpMethod': event['httpMethod'],
        'httpStatusCode': 200,
        'responseBody': response_body
    }

    responses.append(action_response)

    api_response = {
        'messageVersion': '1.0', 
        'response': action_response}

    return api_response

Step 4. Setup the instruction for the Bedrock Nova Pro agent

You are an agent assisting customers with purchasing shoes. You must greet by saying "Hi. I am a virtual retail agent. Tell me what you're looking for, and I'll help you find the perfect fit." Then, to find the best fit, you may ask customers about their favorite color, foot length, and intended use of the shoes, but should not ask all these at once. Once you have information about foot length, favorite color and intended use, check the inventory for shoes that match these criteria. Generate a response that includes the shoe ID, style description, available colors, and sizes based on the inventory details. If multiple matches are found, display all options to the customer.

If there are no products that have the preferred size, offer the nearest size and inform the customer that the shoe can be tight if the alternative size is smaller, or loose if the alternative size is bigger than the preferred size.

Order Placement:
- After the customer selects a shoe, ask for the customer ID and the number of products that they want to buy. Use the chosen shoe ID, customer ID and the number of products that customer wants to buy to place the order, ensuring these shoes are still in stock by checking the inventory count.

Additional Considerations:
- If no matching shoes are available, inform the customer and offer alternatives.
- If the selected shoe is out of stock, notify the customer and suggest other options.

Demo

In this demo, the flow is that first, the customer is looking for a shoe, given specific requirements like foot length and favorite color. Then the agent will query all the shoes in the inventory, and base on the customer's requirements to list the suitable products for the customer. If the customer choose product(s), the agent will ask for the customer name and add the order to the Order table for further processing in the future.

Here is the demo for the retailer agent in the Bedrock playground: https://haianh.s3.us-east-1.amazonaws.com/EnglishRetailer.mp4

Conclusion

This blog has provided a use case for applying Amazon Bedrock Nova Pro model for a virtual retailer.

Free SSL subdomain assigned to AWS EC2 instance with Certbot

Phạm Nguyễn Hải Anh — Mon, 05 May 2025 12:51:23 +0000

Scenario

Sometimes, the EC2 instances, not ALB, need to be assigned SSL certificates as there are some functions required SSL. This blog will guide you how to assign an SSL certificate with a given subdomain and Certbot-NginX.

Prerequisites

An AWS IAM user with admin role
A IP public EC2 Ubuntu instance (I test with version 22.04 LTS)
A domain (I bought in TenTen)

Steps

Associate a AWS EIP to EC2

Step 1. Choose orange button "Allocate Elastic IP address"

Step 2. Keep the default selections and choose orange button "Allocate"

Step 3. Choose the created EIP -> Actions -> Associate EIP address

Step 4. Choose instance -> ID of the EC2 instance you want to assign the certificate -> Associate

The reason why you need EIP is to keep the IP of the EC2 instance when it turns off.

Assign the subdomain to EC2 instance

In this section, I assume that you have already bought a domain, may be through GoDaddy or somewhere else.

Step 1. Go to your domain configuration website and add an A record with value is the IP of EC2 instance. The name is the first part before dot in the domain that you want to configure. For example, you want the EC2 instance hosting a subdomain named transcribe.pngha.io.vn, then the value in the Name column is "transcribe".

Step 2. Wait for at least 1 minute for the record to be activated. Then access the URL of the subdomain:port, for e.g. transcribe.pngha.io.vn:3000.

Congratulation! Now you have linked the IP of EC2 instance to the given domain. In the next section, you will explore how to configure the SSL certificate to encrypt the connection to the domain of the EC2 instance.

Assign free SSL certificates to AWS EC2 instance

Step 1. Run command sudo apt update -y

Step 2. Run command sudo apt upgrade -y

Step 3. Run command sudo apt install nginx -y

Step 4. Run command sudo apt-get install software-properties-common

Step 5. Run command sudo add-apt-repository ppa:certbot/certbot. If you encounter the following error:

Then change the command to sudo apt-add-repository -r ppa:certbot/certbot

Step 6. Then run sudo apt update and sudo apt-get update

Step 7. Install Certbot with command sudo apt-get install python3-certbot-nginx

Step 8. Run command sudo certbot -d transcribe.pngha.io.vn

Step 9. Type y when asked. Then the certificate is requested. Wait for about 4 minutes.

Step 10. You will be issued the certificate successfully

Step 11. You can now access the URL. However, the default website is the Nginx default. If you want custom it, especially when your website is running on a different port (e.g. 3000), you can refer the next section.

Custom the website for HTTPS

Step 1. Run command sudo nano /etc/nginx/sites-available/transcribe.pngha.io.vn and paste the following content:

server {
    listen 80;
    server_name transcribe.pngha.io.vn;

    # Redirect all HTTP requests to HTTPS
    return 301 https://\$host\$request_uri;
}

server {
    listen 443 ssl;
    server_name transcribe.pngha.io.vn;

    # SSL certificate paths (these should match what Certbot created)
    ssl_certificate /etc/letsencrypt/live/transcribe.pngha.io.vn/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/transcribe.pngha.io.vn/privkey.pem;

    include /etc/letsencrypt/options-ssl-nginx.conf;
    ssl_dhparam /etc/letsencrypt/ssl-dhparams.pem;

    # Proxy settings for Node.js application
    location / {
        proxy_pass http://localhost:3000;
    }
}

In this script, I use port 3000 for the website
Step 2. Create link with the command sudo ln -s /etc/nginx/sites-available/transcribe.pngha.io.vn /etc/nginx/sites-enabled/

Step 3. Check with sudo nginx -t. If it shows "nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful", which means OK.

Step 4. Then restart nginx

Step 5. Now you need to make the symbol link from the default changed to your domain by deleting the default

Step 6. Then restart nginx

Step 7. Now start your web server with port 3000. And access transcribe.pngha.io.vn successfully.

Reference

https://www.youtube.com/watch?v=qQl93M7XpJA&ab_channel=SusanB (for A record format).
https://www.youtube.com/watch?v=uEAzcLw_nSI&ab_channel=DebduttaPanda (for assigning cert to subdomain with Certbot).
https://stackoverflow.com/questions/56519434/how-to-add-certbot-to-another-port (johnsing answer for template).
https://stackoverflow.com/questions/60249177/e-the-repository-http-ppa-launchpad-net-certbot-certbot-ubuntu-focal-release.
https://stackoverflow.com/questions/9063378/why-do-browsers-not-use-srv-records (I intend to use SRV records for changing the port, but according to this link, it won't work).

Live Streaming: Real-time translated subtitles with AWS

Phạm Nguyễn Hải Anh — Sat, 03 May 2025 03:42:50 +0000

Scenario

A streaming platform wants to stream sport matches commented in English (of course completely legal) for Vietnamese viewers. They demand that the subtitle needed to be translated to Vietnamese with the lowest latency as possible. This blog is a PoC (Proof of Concept) for the translated streaming subtitle, using AWS Transcribe to transcribe the voice to text, Nova Micro to fix the text and Claude 3.5 Sonnet v2 in Bedrock to translate, with the support of serverless AWS ECS Fargate and Lambda.

Why not using Amazon Translate but use Claude 3.5 Sonnet v2 in Bedrock? It is because the streaming videos are in special contexts, using sports vocabulary such as player names, item names which makes AWS Translate cannot identify and translate correctly.

Workflow

Using OBS studio, a video stream is pushed to Amazon ECS Fargate "stream-server". "Stream-server" uses NGINX-RTMP module to deliver the stream to IVS through RTMPS and to Amazon ECS Fargate "transcribe-server" through RTMP.
Amazon ECS Fargate "transcribe-server" extracts the voice from the stream using FFMEPG, calls AWS Transcribe to transcribe it to text. I have referred an algorithm to extract and appends new words transcribed to a buffer, and send the buffer (then clear it) whenever a punctuation is detected in that buffer. However, since new appended words could be a part of a complete word (e.g. 2008 transcribed to 2 words 20 and 08), Amazon Bedrock Nova Micro is invoked to fix the buffer based on the original livestream.
Amazon ECS Fargate "translate-server" received the transcribed buffer and used Claude 3.5 Sonnet v2 to translate from SourceLanguague to TargetLanguage.

Prerequisite

Amazon Bedrock access to Nova Micro and Claude 3.5 Sonnet v2 models.
The region to run this project must support Amazon IVS.
Editing the package.json in Translate folder and Transcribe folder to contain the bedrock SDK package.

Steps

This project is heavily based on the repository in the #1 Reference. There are few files that I have customized the code.

Transcribe

Keep most of the transcribing part. Just edit the transcribe-to-translate part, which I refer the reference #2.

Slicing New Items for Processing:

const startIndex = translationContext.lastProcessedItemIndex || 0;
const newItems = items.slice(startIndex);

The function determines the startIndex from the last processed index in the translation context. It slices new items from the transcription result starting from the startIndex.

Updating the Last Processed Index:

translationContext.lastProcessedItemIndex = items.length;

Updates the lastProcessedItemIndex to the total number of items, marking all current items as processed.

Building the Untranslated Buffer:

if (newItems.length > 0) {
    const newText = reconstructTranscript(newItems);
    translationContext.untranslatedBuffer += newText;
}

If there are new items, reconstructs their text using reconstructTranscript, then appends the reconstructed text to the untranslatedBuffer.

Checking Translation Readiness:

const shouldTranslate = checkShouldTranslate(translationContext.untranslatedBuffer);

function checkShouldTranslate(buffer) {
  // Check for sentence-ending punctuation
  const punctuationRegex = /[.!?。！？]/;
  const commaRegex = /[,]/;
  if (punctuationRegex.test(buffer)) {
    return true;
  }
  if (buffer.length > 60 && commaRegex.test(buffer)) {
    console.log("more than 60 char & comma: ", buffer)
    return true;
  }
  // Check if word count exceeds threshold (14 words) and ends with comma
  // const words = buffer.trim().split(/\s+/);
  if (buffer.length > 76) {
    console.log("more than 76 char: ", buffer)
    return true;
  }

Calls checkShouldTranslate to determine if the untranslatedBuffer is ready for translation.

If yes, then go to text correction before sending to the "translate-server":

if (shouldTranslate || !result.IsPartial) {
    const prompt = `You receive a processed text and a reference text. 
    IMPORTANT: Fix ONLY the actual errors in the range of processed text by referring to the reference text. If the reference text is completely different, or has more content, return the processed text as is.
    Reference text: ${parsedTranscription.text}
    Return ONLY fixed text, no explanations.
    Example: 
      Processed text: "A strong refer needed today , Howard Webb , is that , England'sA strong refer needed today , Howard Webb , is that , England's represent at Euro 20 ."
      Reference text: "Not many managers can claim degree of success. A strong referee needed today, Howard Webb is that man, England's representative at Euro 2008"
      Response: "A strong referee needed today, Howard Webb is that man, England's representative at Euro 2008"
    Processed text: ${translationContext.untranslatedBuffer}`;

    const message = {
        content: [{ text: prompt }],
        role: ConversationRole.USER,
    };
    const request = {
      modelId,
      messages: [message],
      inferenceConfig: {
        maxTokens: 500, // The maximum response length
        temperature: 0.0, // Using temperature for randomness control
        top_K: 1,        // Alternative: use topP instead of temperature
      },
    };
    const response = await client.send(new ConverseCommand(request));
    const ModelHandledUntranslatedBuffer = response.output.message.content[0].text;
    translationContext.untranslatedBuffer = ModelHandledUntranslatedBuffer;
}

Constructs a prompt for a language model to fix errors in the untranslatedBuffer by comparing it to the parsedTranscription.text.
Sends the prompt via a ConverseCommand to the language model.
Updates the untranslatedBuffer with the model's corrected response.

The effectiveness of Nova Micro:

untranslatedBuffer:   200
partial live:  2008.
ModelHandledResult:  2008.

The processed buffer can not add the 8 character from the original subtitle. Nova Micro is invoked to fix it.

Besides, add a custom vocabulary list (.txt format, separated by tab) in Amazon Transcribe in the console to better transcribe the soccer players and club names:

Phrase  IPA SoundsLike  DisplayAs
Amazon  æ m ə z ɑ n      Amazon
I.V.S.  aɪ v i ɛ s        IVS
Twitch      twitch  Twitch
Szczesny            Szczesny
Danilo          Danilo
Bonucci         Bonucci
Boucci          Bonucci
De-Ligt         De Ligt
Alex-Sandro         Alex Sandro
Alexandra           Alex Sandro
Alexandro           Alex Sandro
Chiesa          Chiesa
Chiea           Chiesa
McKennie            McKennie
Bentancur           Bentancur
Bentanco            Bentancur
Ramsey          Ramsey
Dybala          Dybala
Paulo-Dybala            Paulo-Dybala
Cristiano-Ronaldo           Cristiano-Ronaldo
Andrea-Pirlo            Andrea-Pirlo
Andrea          Andrea
Pirlo           Pirlo
Juventus            Juventus
Ju-V.           JUV
JuVe            JUV
Ju-Ve           JuV
Udinese         Udinese
Udi         Udinese
U-di            UDI
Musso           Musso
Moosa           Musso
Mooso           Musso
Mosso           Musso
Mousso          Musso
Bonifazi            Bonifazi
De-Maio         De Maio
De-Mao          De Maio
De-Ma-O         De Maio
Samir           Samir
Stryger-Larsen          Stryger-Larsen
De-Paul         De Paul
Walace          Walace
Wallace         Walace
Pereyra         Pereyra
Zeegelaar           Zeegelaar
Aal         Zeegelaar
Lasagna         Lasagna
Pussello            Pussello
Serie-A.            Serie A
amer            amer

Translate

Using the idea of Reference #2, which is translating the transcription but also keeping previous translated words as many as possible. The latency when invoking Claude 3.5 Sonnet is about 2.8s to 3.7s.

Demo

https://david-gapv.s3.ap-southeast-1.amazonaws.com/FixName_Delay5sExchangeMediumAccura.mp4

Reference

How to leave AWS Organization with root access management after Landing Zone deployment

Phạm Nguyễn Hải Anh — Sun, 26 Jan 2025 16:09:05 +0000

Introduction

The Control Tower Landing Zone is a starting point for organizations to quickly deploy workloads. However, the cleaning up process is not as quick as the deployment process, as it takes 90 days to completely close an AWS account that has been deployed by Control Tower using an existing email. Consequently, the management account in that AWS Organization cannot be used to deploy other Landing Zone for 90 days. To deal with this problem, this blog proposes a solution to make the management account available more quickly for other Landing Zone deployment, with the help of a new IAM feature called root access management.

Prerequisites

All accounts created by Control Tower Landing Zone must use existing emails.
The Landing Zone has been decommissioned. ## Implementation Step 1: In the Management Account, go to the IAM Dashboard. Then select Account settings on the left sidebar. Click the Enable button in the “Centralized root access for member accounts” section:

Step 2: Enter the account ID of an account within the Organization. This account will become the Delegated Administrator for the IAM service:

Step 3: In the IAM Dashboard, select the Root access management tab on the left sidebar. Select one account that is not delegated IAM administrator (in this case I choose the Production account) and choose "Take privileged action":

Step 4: Select “Allow password recovery”:

Step 5: Log in to the root account with the email haithe123123@yahoo.com (log in to your account), and receive "password reset requirement" notification:

Step 6: Click Forgot password then an email will be sent:

Step 7: Check the email (in my case, I check Yahoo):

Step 8: Click the link in the email and enter a new password:

Step 9: You will receive a new email notifying you that the account password has been successfully reset:

Step 10: Log in using the new password:

Step 11: Set up a payment method in the Billing Dashboard in the Payment Preferences section on the left sidebar. Click the Add payment method button:

Step 12: Enter the card information (😊) and enable “Set as default payment method”

Step 13: Fill in the remaining information (for legal purposes) and submit:

Step 14: Go to the Organization and leave by selecting “Leave this organization”:

Step 15: Confirm leaving

Step 16: The system will display an error. Click on the link to complete the account information:

Step 17: Enter the personal phone number

Step 18: AWS will call the phone number, switch to the keypad and enter the number provided on the browser screen

Step 19: After entering the number, the browser will redirect to support plan selection page. Select “Basic support – Free” and click “Complete sign up”:

Step 20: You can see the email about AWS Support Sign-Up Confirmation notification:

Step 21: Return to the account, go to the Organization, and select remove the account. You will be notified that it may take a few days:

or can successfully leave the Organization

Step 22: Repeat these steps for the remaining member accounts.

Eventually, you can close these member accounts, or use them as new management accounts in other unique AWS Organizations.