AWS と NVIDIA が業務用エージェントワークフローを公開

Fast-growing companies and enterprise supply-chain teams often have enough data to see that something is wrong, but not enough time to manually investigate every disruption. A supplier delay can require a planner to check purchase orders, inventory, customer commitments, contract rules, logistics options, and approval policies before deciding what to do next.

Dashboards help teams see what’s happening. The harder part is turning that signal into a reliable decision workflow that recommends what to do next and shows the evidence behind the recommendation.

In this post, we show how Amazon Quick can serve as the business-user front door for specialized agent workflows. We use the NVIDIA NeMo Agent Toolkit to build a supply-chain risk example that helps a planner move from an Amazon Quick dashboard and knowledge context to a guided mitigation recommendation.

Solution overview

To address this challenge, we combine Amazon Quick and NVIDIA NeMo Agent Toolkit. Amazon Quick gives business users a single conversational workspace for structured data and unstructured enterprise knowledge. Knowledge sources can include Amazon Simple Storage Service (Amazon S3), Google Drive, Microsoft SharePoint, Atlassian Confluence, and internal web content. In that workspace, users can connect to over 100 pre-built action connectors to perform actions in third-party systems such as Microsoft Outlook, Slack, Jira, and Asana. They can also invoke agentic workflows exposed through Model Context Protocol (MCP). NVIDIA NeMo Agent Toolkit is an open source, framework-agnostic library for connecting, evaluating, profiling, and optimizing agentic workflows. It works alongside popular frameworks such as LangChain, LlamaIndex, CrewAI, Microsoft Semantic Kernel, Google ADK, and custom Python agents.

In this solution, supply-chain analysts use an Amazon Quick chat agent to diagnose issues through an Amazon Quick Sight NeMo Agent Toolkit workflow. The workflow investigates the disruption, calls supply-chain tools, validates the recommendation, and returns a ranked mitigation plan to the planner.

If you’re a supply-chain operations leader, analyst, or builder, you can use this post to learn how to move from dashboard context to a mitigation plan in Amazon Quick. If you’re an engineering leader or developer, you can see how to build the backend agentic workflow with NVIDIA NeMo Agent Toolkit while Amazon Quick serves as the front door for business users. If you’re part of a startup, you can also use this approach to scale operations without adding large planning teams. As order volume, suppliers, and customer commitments grow, the same architecture can help your team make faster and more repeatable supply-chain decisions.

You can also use NVIDIA NeMo Agent Toolkit to inspect and evaluate agentic workflows with telemetry, per-step latency, and evaluation results. These signals help you tune the workflow, its tools, and its orchestration logic. This observability becomes more important as teams move from simple chat assistants to agentic workflows.

Architecture overview

In this architecture, Amazon Quick provides the business-user interface, dashboard context, knowledge access, and action trigger. Amazon Bedrock AgentCore provides the MCP gateway and runtime hosting path. NeMo Agent Toolkit owns the backend agentic workflow: registering tools, orchestrating the supply-chain investigation, capturing execution traces, and supporting evaluation and profiling so developers can improve the workflow before production.

Figure 1 illustrates how Amazon Quick, AgentCore Gateway, AgentCore Runtime, and NeMo Agent Toolkit work together.

*Figure 1 — Solution architecture. Amazon Quick provides the dashboard, knowledge context, and action trigger. AgentCore Gateway exposes the MCP action, and AgentCore Runtime hosts the NeMo Agent Toolkit workflow container*

There are two user patterns in the solution. First, the analyst asks diagnostic questions that Amazon Quick can answer from the dashboard and Amazon S3 knowledge source.

*Figure 2 — Diagnostic flow. Amazon Quick uses dashboard and knowledge context to answer “what is happening?” questions before a backend action is triggered*

Second, when the analyst asks what to do next, Amazon Quick invokes the NeMo-backed MCP action.

*Figure 3 — Action flow. Amazon Quick calls the MCP action, AgentCore invokes the runtime, and NeMo runs the backend decision workflow to return a mitigation plan*

For readers new to NeMo Agent Toolkit, the backend workflow has three code layers: registered functions, a workflow configuration file, and an orchestrator. Registered functions are reusable capabilities such as purchase order risk, inventory exposure, customer impact, policy lookup, logistics options, and mitigation recommendation. The workflow configuration names those functions and wires them into one decision workflow. The orchestrator receives the request, calls the functions in sequence, and returns the mitigation plan with evidence, trace, latency, and evaluator metadata.

Step 3 moves into those implementation details and explains what runs inside the NeMo Agent Toolkit workflow container.

Implementation steps

The accompanying repository includes the AWS CloudFormation template, deployment scripts, sample data, the NeMo Agent Toolkit workflow plugin, and Quick setup notes.

Prerequisites

To deploy and test the sample, you need:

• An AWS account with access to Amazon Quick, Amazon Bedrock AgentCore Runtime, and Amazon Bedrock AgentCore Gateway.

• AWS Command Line Interface (AWS CLI) v2.

• Python 3.11+ for optional local NeMo validation. Docker is not required locally because the quickstart uses AWS CodeBuild to build and push the AgentCore Runtime container image.

• AWS Identity and Access Management (IAM) permissions to deploy AWS CloudFormation stacks that create IAM roles, Amazon S3 buckets, Amazon Elastic Container Registry (Amazon ECR) repositories, AWS CodeBuild projects, AWS Lambda functions, and Amazon Bedrock AgentCore resources.

• An Amazon Quick or Amazon Quick Sight user with permissions to create analyses, datasets, knowledge integrations, chat agents, and MCP action integrations.

Step 1: Clone the repository

Clone the repository so the deployment scripts, AWS CloudFormation template, sample data, and NeMo Agent Toolkit workflow code are available locally.

git clone https://github.com/aws-samples/sample-amazon-quick-nvidia-nemo-agent-toolkit
cd amazon-quick-nemo-supply-chain-risk

Step 2: Authenticate to AWS

Authenticate with the AWS account where you plan to deploy the sample. These commands configure an IAM Identity Center / SSO profile, start a browser-based sign-in flow, set the active CLI profile, and verify the account identity before the infrastructure is created. For Mac or Linux:

aws configure sso
aws sso login --profile 
export AWS_PROFILE=
aws sts get-caller-identity

For Windows PowerShell:

aws configure sso
aws sso login --profile 
$env:AWS_PROFILE=""
aws sts get-caller-identity

The aws sso login command starts authentication in your browser. If you already have an active AWS SSO session, use that browser session to complete authentication. Verify that the returned AWS account is the account where you want to deploy the sample.

Step 3: Deploy the sample solution

Set the AWS Region and stack name before running the deployment script. The Region determines where the sample infrastructure is created, and the stack name keeps the generated resources grouped for later cleanup.

Mac or Linux:

export AWS_REGION=us-east-1
export STACK_NAME=sc-risk-copilot-dev
./scripts/deploy.sh

Windows PowerShell:

$env:AWS_REGION="us-east-1"
$env:STACK_NAME="sc-risk-copilot-dev"
.\scripts\deploy.ps1

The deployment script performs the following tasks:

• Deploys the base AWS CloudFormation stack.

• Uploads the sample datasets and knowledge documents to Amazon S3.

• Uses AWS CodeBuild to build and push the NeMo backend container image to Amazon ECR, so Docker isn’t required locally.

• Updates the CloudFormation stack to deploy Amazon Bedrock AgentCore Runtime.

• Creates an Amazon Bedrock AgentCore Gateway MCP Lambda target.

• Writes the manual Amazon Quick setup values to outputs/quick-setup.txt.

The script uses AWS CloudFormation for the AWS infrastructure. See steps 5 through 7 for guidance to set up the Amazon Quick dashboard, knowledge source, chat agent, and MCP action connection.

What runs inside the NeMo Agent Toolkit workflow

The NeMo Agent Toolkit workflow runs inside an Amazon Bedrock AgentCore Runtime container. Amazon Quick invokes the MCP action through Amazon Bedrock AgentCore Gateway. Gateway calls a Lambda target adapter, and the adapter invokes the runtime endpoint. Inside the container, FastAPI receives the /invocations request and loads the NeMo Agent Toolkit workflow. The supply_chain_risk_orchestrator composes the following registered functions into one workflow and returns the ranked mitigation plan with evidence, trace, latency, and evaluator metadata.

• po_risk_tool: Finds delayed purchase orders and affected SKUs.

• inventory_exposure_tool: Calculates days of supply and stockout risk.

• customer_impact_tool: Maps constrained SKUs to customer orders, revenue, priority, and SLA exposure.

• contract_policy_tool: Checks contract, sourcing, freight approval, and substitution rules.

• logistics_options_tool: Finds expedite, transfer, or alternate supplier options.

• mitigation_recommendation_tool: Ranks mitigation options and returns critic checks.

*Figure 4 — NeMo Agent Toolkit workflow inside the runtime container. The supply_chain_risk_orchestrator coordinates the registered supply-chain functions and returns both the mitigation decision package and reliability metadata to Amazon Quick*

NeMo Agent Toolkit workflow configuration

The backend decision logic is defined as a NeMo Agent Toolkit workflow configuration. The YAML gives each registered function a local name, then the orchestrator resolves the configured functions in its Python registration code. For more detail, see the NeMo Agent Toolkit docs on custom functions.

# Each entry under functions configures a function available to the workflow
# The _type value maps to a registered NeMo function in the plugin code.
functions:
  po_risk:
    _type: po_risk_tool
  inventory_exposure:
    _type: inventory_exposure_tool
  customer_impact:
    _type: customer_impact_tool
  contract_policy:
    _type: contract_policy_tool
  logistics_options:
    _type: logistics_options_tool
  mitigation_recommendation:
    _type: mitigation_recommendation_tool

# The workflow section defines the entry point and wires in the functions.
workflow:
  _type: supply_chain_risk_orchestrator
  po_risk_fn: po_risk_tool
  inventory_fn: inventory_exposure_tool
  customer_impact_fn: customer_impact_tool
  contract_policy_fn: contract_policy_tool
  logistics_fn: logistics_options_tool
  mitigation_fn: mitigation_recommendation_tool

This makes the workflow explicit and testable: the functions can be instrumented, tested, reused, and included in NeMo Agent Toolkit evaluation and profiling workflows. In production, replace the sample CSV-backed functions with governed data tools such as Amazon Athena queries, RDS queries, ERP APIs, WMS/TMS APIs, or other MCP tools.

Step 4: Review the outputs

Review the generated setup file:

amazon-quick-nemo-supply-chain-risk/outputs/quick-setup.txt

The file includes the Amazon S3 location of the dashboard CSV, the S3 prefix for knowledge documents, the S3 prefix for evaluation data, the AgentCore Gateway MCP endpoint URL, the demo authentication guidance, and the suggested Quick test prompts.

Step 5: Create the Amazon Quick Sight dashboard

Use the flattened CSV dataset that’s already included in the repo:

amazon-quick-nemo-supply-chain-risk/sample-data/quick/supply_chain_risk_view.csv

The deployment also stages the same file in the Amazon S3 bucket created by AWS CloudFormation. You can find that path in outputs/quick-setup.txt as Quick dashboard CSV. To use the deployed copy instead of the local repo file, download it first:

aws s3 cp s3:///quick/supply_chain_risk_view.csv ./supply_chain_risk_view.csv

From Amazon Quick, choose Analyses, choose Generate analysis, add data, create a dataset, and upload supply_chain_risk_view.csv. Figure 5 shows the Generate analysis experience with the sample dashboard prompt.

*Figure 5 — Generate analysis prompt. The sample prompt asks Amazon Quick to create an executive supply-chain risk dashboard from the uploaded CSV dataset*

Use this prompt:

Create an executive supply-chain risk dashboard for supplier delays and stockout risk. Include visuals for late purchase orders by supplier, revenue at risk by customer priority, high-risk SKUs by distribution center, days of supply by SKU, mitigation type, approval required, and supplier on-time rate. Add filters for supplier, SKU, risk level, and distribution center. Organize the dashboard for a supply-chain leader who needs to know what is at risk and where to act first.

Choose Preview analysis outline, review the outline, and then choose Generate. Figures 6 and 7 show examples of the generated dashboard pages.