https://github.com/4379711/amz-ad-pilot
AI-powered Amazon SP ads platform: campaign automation, analytics, and an LLM autopilot agent. Go + Vue 3, self-hosted.
https://github.com/4379711/amz-ad-pilot
ad-optimization adtech advertising ai ai-agents amazon amazon-ads amazon-advertising amazon-ppc amazon-sp-api automation autonomous-agents ecommerce llm marketing-automation ppc ppc-optimization self-host
Last synced: 2 days ago
JSON representation
AI-powered Amazon SP ads platform: campaign automation, analytics, and an LLM autopilot agent. Go + Vue 3, self-hosted.
- Host: GitHub
- URL: https://github.com/4379711/amz-ad-pilot
- Owner: 4379711
- License: other
- Created: 2026-06-12T03:00:46.000Z (16 days ago)
- Default Branch: main
- Last Pushed: 2026-06-26T10:02:31.000Z (2 days ago)
- Last Synced: 2026-06-26T11:08:42.642Z (2 days ago)
- Topics: ad-optimization, adtech, advertising, ai, ai-agents, amazon, amazon-ads, amazon-advertising, amazon-ppc, amazon-sp-api, automation, autonomous-agents, ecommerce, llm, marketing-automation, ppc, ppc-optimization, self-host
- Language: Go
- Homepage:
- Size: 4.16 MB
- Stars: 4
- Watchers: 0
- Forks: 1
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- Contributing: CONTRIBUTING.md
- License: LICENSE
- Code of conduct: CODE_OF_CONDUCT.md
- Security: SECURITY.md
Awesome Lists containing this project
README
# amz-ad-pilot
**AI-powered Amazon Ads operating platform — Sponsored Products automation, deep analytics, and an LLM-driven optimization agent, all in one box.**
[简体中文](./README.zh-CN.md) · English
[](https://go.dev/)
[](https://vuejs.org/)
[](https://vitejs.dev/)
[](https://element-plus.org/)
[](https://www.mysql.com/)
[](https://redis.io/)
---
## Table of Contents
- [What is amz-ad-pilot](#what-is-amz-ad-pilot)
- [Highlights](#highlights)
- [Screenshots](#screenshots)
- [Architecture](#architecture)
- [AI Autopilot Execution Logic](#ai-autopilot-execution-logic)
- [Repository Layout](#repository-layout)
- [Quick Start](#quick-start)
- [Build & Release](#build--release)
- [Tech Stack](#tech-stack)
- [Roadmap](#roadmap)
- [Contributing](#contributing)
- [License](#license)
- [Disclaimer](#disclaimer)
---
## What is amz-ad-pilot
`amz-ad-pilot` is a self-hosted SaaS-style platform for **Amazon Sponsored Products** sellers and agencies. It pulls raw advertising and Seller Central data through the official APIs, materialises it in your own MySQL, then layers an analytics console and an **LLM-driven optimization agent** on top.
The product covers the full ads operation loop:
1. **Pull** — campaigns, ad groups, keywords, product ads, targets, negative entities, ad reports, SC reports, orders and inventory are synchronised on a schedule by the standalone `datas` worker.
2. **Analyse** — the `web` service exposes the full dashboard: overview metrics with WoW/YoY comparison, placement breakdown, auto-vs-manual contrast, bid-ladder analysis, search-term funnel, keyword lifecycle, break-even diagnostics and budget utilisation — with a switchable attribution window (1/7/14/30-day) across every view and one-click CSV export.
3. **Act** — operators can edit campaigns/ad groups/keywords directly, run dayparting (`schedule`, incl. a 24×7 percentage-slot template) and a rule-based negation engine, negate / harvest / ask-AI straight from analytics rows, or hand the wheel to the **AI Agent** that proposes, executes and audits bid / budget / placement / keyword changes through SP-API.
4. **Observe** — every AI run is fully audited: world snapshot, LLM messages, tool calls, token cost and rationale are persisted in `amz_ai_agent_runs` for review.
---
## Highlights
### Full Sponsored Products coverage
- Campaign / Ad Group / Keyword / Product Ad / Target CRUD with bi-directional sync to SP-API.
- Negative keywords and negative targets at both campaign and ad-group levels.
- **Rule-based negation engine** — deterministic zero-conversion judgement on settled data (attribution closed), preview the hits then batch-negate in one click; no LLM, no token cost.
- Bulk operations with `clause.OnConflict{UpdateAll: true}` upserts (batch size 500).
### Deep advertising analytics
- **Overview v2** with WoW & YoY comparison, store sales, ad sales, organic sales, ACOS / TACOS / ROAS.
- **Switchable attribution window** — 1 / 7 / 14 / 30-day click attribution across every analytics view (7-day is Amazon's billing calibre).
- **Placement** breakdown across Top of Search / Product Pages / Rest of Search.
- **Auto vs Manual** campaign performance comparison.
- **Bid ladder** — buckets of bid prices and their effective performance.
- **Search-term funnel** — keyword → search term traffic flow.
- **Keyword lifecycle** — new / paused / active keyword cohorts.
- **Optimization diagnostics** — spend (settled-window calibre to avoid false kills), budget utilisation, break-even guard rails.
- **Analytics-to-action** — negate, harvest into a keyword, or ask the AI with full context straight from search-term / waste rows; one-click CSV export.
- **Data quality** dashboard — report freshness & completeness traffic light.
### AI Agent (LLM-driven autopilot)
- Tool-calling agent built on top of OpenAI-compatible Responses API (GPT-5 family by default).
- **Chat mode** — operators converse with the agent over SSE; the agent can call diagnostic tools in parallel and propose actions one at a time.
- **Autopilot mode** — cron-driven `RunTick`; the agent reviews a world snapshot per campaign batch and proposes `adjust_bid` / `adjust_budget` / `adjust_placement` / `add_keyword` / `negate_keyword` / `pause` / `enable` actions, supporting Shadow (record only) / Approval (human-confirmed) / Full (auto-execute) modes (`run_mode` 1 / 4 / 3).
- **Promo calendar** — operators maintain promo/event dates; the agent recognises ramp-up (14 days before) / peak / recovery (5 days after) phases and switches its promo playbook accordingly.
- **Shared executor** — chat and cron share the same execution layer so audit, idempotency and rate-limit are guaranteed.
- **Auto-compact** — historical messages are summarised by a cheaper model (`gpt-5-mini` by default) when the prompt approaches the model context window, keeping cost flat across long sessions.
- **Cost & quota guards** — per-chat tool-call cap, per-tool result token cap, circuit breaker, prompt-cache aware pricing.
### Dayparting (`schedule`)
- 24×7 bid / budget / state schedules with second-level granularity.
- **Dayparting template** — describe a weekly rhythm as "weekday × hour × percentage slots" (e.g. 60% overnight, 130% weekend prime time); evaluated hourly in the marketplace timezone against a base value captured at binding time, uncovered hours fall back to 100%.
- Cron-driven scheduler with per-task lock and audit trail.
### Single-binary deployment
- Vue dist is `//go:embed`-ed into the Go binary by default.
- `external_config` build tag lets the binary read `config-prod.yaml` from disk for ops-friendly tweaking.
- Cross-compile to Linux / macOS / Windows with one script.
---
## Screenshots
Organised by the top-level menus of the UI. Each module ships more pages than shown — the screenshot only illustrates one of them.
### Dashboard (首页)
Overview KPIs with WoW comparison, total-trend (with TACOS) chart and AI autopilot status panel.
### Ad Analytics (广告分析)
Seven analysis views: **Ad Data · Placement Analysis · Auto vs Manual · Bid Ladder · Search-Term Funnel · Keyword Lifecycle · Optimization Diagnosis**.
> Shown below: Placement Analysis — Top of Search / Rest of Search / Product Pages / Off-Amazon comparison chart with per-placement metrics (impressions, clicks, spend & sales share, CTR).
### Ads Management (广告管理)
**Campaigns · Ad Groups · Targeting · Product Ads · Negative Keywords · Negation Rules · Dayparting** — full SP entity CRUD with bi-directional SP-API sync.
> Shown below: Campaigns — bidding strategy, budget, AI-autopilot toggle and inline edit.
### AI Autopilot (AI 托管)
**AI Chat · Strategy Config · Playbook Library · Promo Calendar · SKU Cost**.
| AI Chat | Strategy Config | Playbook Library |
|---------|-----------------|------------------|
|  |  |  |
- **AI Chat** — SSE chat with the LLM agent: tool proposals, decision table, token / cache / reasoning meters and per-call cost.
- **Strategy Config** — Shadow / Approval / Full run modes, global kill switch, per-run history and decision audit.
- **Playbook Library** — guardrail & playbook rules that steer the agent, with scope, priority and per-rule enable / edit controls.
- **Promo Calendar** — maintain Prime Day / BFCM dates; the agent auto-switches ramp-up / peak / recovery pacing.
- **SKU Cost** — unit-economics input from which break-even ACOS is derived.
### Smart Operations (智能运营)
**Approval Center · Alerts · AI Action Log · Outcome Board**.
> Shown below: Alerts — operation alerts grouped by type (data quality, budget burn-out, sync failure) with severity and unread tracking.
### System Settings (系统设置)
**Sellers · Users · System Params** — store binding, account management and global runtime parameters.
---
## Architecture
```text
┌─────────────────────────────────────────────┐
│ Operators │
│ (Browser → Vue 3 dashboard / SSE chat) │
└─────────────────────┬───────────────────────┘
│ /api → :43000
▼
┌─────────────────────────────────────────────────────────────┐
│ amz-ad-pilot-go · cmd/web (Fiber) │
│ ├─ biz/campaign,adgroup,keyword,… CRUD & sync │
│ ├─ biz/ad_analysis 8 analytic views │
│ ├─ biz/schedule dayparting scheduler │
│ ├─ biz/ai_agent + ai_engine LLM autopilot + chat │
│ ├─ biz/shared_executor SP-API execution │
│ └─ web_ui (embed Vue dist) │
└────────────────┬────────────────────────────────────────────┘
│ ▲
▼ │ HTTPS
┌────────────────────────────┐ ┌────────────────────────────┐
│ MySQL 8.0 (utf8mb4) │ │ OpenAI-compatible LLM │
│ - amz_sp_campaigns_basal │ │ (GPT-5 / gpt-5-mini etc.) │
│ - amz_ai_chat_messages │ └────────────────────────────┘
│ - amz_ai_agent_runs(audit)│ ▲
│ - … │ │ tool calls
└──────────────┬─────────────┘ │
│ │
│ │
┌──────────────▼───────────────┐ ┌──────────┴─────────────────┐
│ Redis 7 │ │ github.com/4379711/amz-sdk│
│ - token cache / locks │ │ (Amazon SP-API + Ads SDK) │
└──────────────────────────────┘ └──────────────┬─────────────┘
│
▼
┌──────────────────────────────┐
│ amz-ad-pilot-go · cmd/datas │
│ cron pulls reports/inv/… │
└──────────────────────────────┘
```
- Frontend dev server (`:9000`) proxies `/api` to the backend (`:43000`).
- Production build embeds the frontend dist into the same Go binary, so users only run one process.
- The standalone `datas` binary is a cron worker that pulls SP-API / Ads-API data on a schedule and writes into the same MySQL.
---
## AI Autopilot Execution Logic
The AI has two entry points that share one execution layer (`shared_executor`) — audit, guardrails, idempotency and rate-limit are unified:
- **Chat** — operators talk to the agent over SSE, executing immediately or approving proposals one by one.
- **Autopilot (cron)** — `robfig/cron` drives `RunTick` on the strategy's cadence for unattended batch decisions.
### What the AI actually decides: rules vs. AI
This is **not** "dump the data into an LLM and let it do whatever". The work is split into *rules compute → AI judges → rules backstop*:
1. **Rules compute the P&L yardstick first (no AI)** — from SKU cost and your objective (profit / balance / growth), a fixed formula derives each campaign's *break-even ACOS* and *target ACOS ceiling*. Pure arithmetic: stable, free, never hallucinated — so the AI never does it.
2. **Hand the yardstick + real performance to the AI** — e.g. "this campaign: ceiling 35%, recent actual 47%", with an explicit instruction: the numbers are pre-computed, use them, do **not** recompute.
3. **The AI judges within the yardstick (its real value)** — it is not an "over the line → cut bid" machine. It first checks inventory (don't pour spend into an out-of-stock SKU), whether it's a new listing (don't kill it on short-term ACOS), digs into search terms to find money-burning queries to negate, and looks at whether similar past adjustments actually worked — then decides **whether to act, which target, which action, how much**. That multi-signal weighing is exactly what hard-coded if/else can't cover and an LLM is good at.
4. **Rules backstop last** — every bid / budget / delta the AI emits is re-checked against absolute min/max and per-step caps before it ships; anything out of range is blocked. The AI's freedom is boxed into a safe range.
In one line: **the ACOS ceiling and friends are red lines that the rules draw for the AI — the AI never recomputes them, it only decides *how to move* within those lines using inventory / lifecycle / search-term / historical-win-rate evidence, and a hard guardrail backstops the result.**
### One autopilot decision loop (`RunTick`)
```mermaid
flowchart TD
A["cron fires on strategy cadence"] --> B["acquireRun lock
anti re-entry + reclaim zombie runs"]
B --> C["data-quality check
report freshness traffic light"]
C -->|"RED & not Shadow"| Z["skip this tick · no LLM call"]
C -->|"GREEN / YELLOW"| D["build WorldSnapshot
metrics aggregated per campaign tree"]
D --> E["sort by priority
cap to Top-N campaigns"]
E --> F["per-campaign LLM
multi-round read-only tools → propose"]
F --> G["each propose passes server-side gates"]
G -->|"pass"| H["shared_executor → SP-API
idempotency key + 5 TPS limit + bulk-response check"]
G -->|"blocked"| J["counted as skipped · reason into rationale"]
H --> L["finalizeRun persists audit
snapshot / messages / decisions / token"]
L --> M["evaluate effect after horizon
outcome feeds the next round"]
```
1. **One campaign per batch** — the LLM calls read-only diagnostic tools across multiple rounds to gather evidence, then emits `propose_*` actions; no evidence, no fabrication.
2. **Six gates before any real change ships** — managed scope → data-quality RED block → bid/budget/delta hard guardrails → server-side product-risk check for spend-increasing actions (out-of-stock / lost Buy Box / unsellable blocks the action, never relying on the LLM's self-discipline) → cooldown & daily cap → short-circuit if equal to current value.
3. **Fully audited** — world snapshot, LLM messages, raw decisions, token/cost are written to `amz_ai_agent_runs` for round-by-round replay.
### Three run modes (`run_mode`)
| Mode | Behaviour | Use case |
|---|---|---|
| **Shadow** | Records decisions only, never calls SP-API | Offline validation of a new strategy |
| **Approval** | Writes pending records; ships only after an operator confirms each in the ops log | Semi-autopilot with human review |
| **Full** | Ships automatically | Full autopilot |
### Safety & cost control
- **Layered hard guardrails** — absolute bid/budget min-max + per-step delta cap + placement-bid cap; any LLM overstep is blocked, never shipped.
- **Three-scope kill switch** — global / seller / strategy, each hot-toggleable to pause the agent's automatic runs and real dispatch (human-initiated chat sends, approval executions and manual schedules still pass, flagged with risk), persisted and restored on restart.
- **Anti-flapping** — minimum cooldown between two real changes to the same target + a daily count cap.
- **Idempotency + rate-limit** — the same decision ships at most once within a short window; a 5 TPS token bucket per seller.
- **Circuit breakers** — LLM consecutive-failure breaker; a strategy that fails N consecutive cron runs is auto-disabled and alerted.
- **Cost savers** — per-tick campaign cap, RED short-circuit to save tokens, long-session auto-compact summarisation, prompt-cache aware pricing.
### Evidence & self-review
- **Read-only evidence tools** — store overview, campaign diagnosis, target health, search terms, per-placement performance, inventory / Buy Box / Listing risk, lifecycle, unit economics, past action outcomes, official bid recommendations, and more.
- **Action tools** — `adjust_bid` / `adjust_budget` / `adjust_placement` / `add_keyword` / `negate_keyword` / `negate_target` / `remove_negative_keyword` / `pause` / `enable` / `create_campaign`.
- **Outcome review** — after an action matures past the look-back window, before/after ACOS / spend / sales / estimated profit are compared and tagged `improved / worsened / neutral`, feeding back into the next round to form a self-correcting loop.
---
## Repository Layout
```text
amz-ad-pilot/
├── amz-ad-pilot-go/ # Go backend (Fiber + Wire + GORM)
│ ├── cmd/
│ │ ├── web/ # HTTP API + embedded Vue UI
│ │ └── datas/ # Offline data puller (SP-API / Ads-API)
│ ├── configs/ # YAML configs + build-tag switch
│ ├── internal/
│ │ ├── biz/ # Business modules (5-file convention)
│ │ ├── datas/ # Sync workers grouped by ad / sc / factory
│ │ ├── datasource/ # MySQL / Redis providers (wire)
│ │ └── wirex/ # Generated DI graph
│ ├── pkg/ # Reusable utilities (logger, paging, etc.)
│ └── scripts/ # build & wire generators + init/update SQL
├── amz-ad-pilot-vue/ # Vue 3 frontend (Vite + Element Plus)
│ └── src/
│ ├── api/ # Module-by-module HTTP clients
│ └── views/admin/ # File-based routing (vite-plugin-pages)
├── .github/workflows/ # CI: go build / yarn build
├── docs/screenshots/ # Drop screenshots here for the README
├── CONTRIBUTING.md
├── CODE_OF_CONDUCT.md
├── SECURITY.md
├── LICENSE
└── README.md
```
### External dependency: `amz-sdk`
The backend depends on [`github.com/4379711/amz-sdk`](https://github.com/4379711/amz-sdk) — a separately released Go module that wraps Amazon Ads & Selling Partner APIs (LwA auth, retries, throttling, observability). It is pulled as a normal versioned dependency:
```go
require github.com/4379711/amz-sdk v1.0.0
```
`go mod download` / `go build` fetches it through Go's module proxy automatically. No `replace` directive needed for the default workflow.
See [`amz-ad-pilot-go/README.md`](amz-ad-pilot-go/README.md#amz-sdk-dependency) for the in-tree development setup (when you want to patch the SDK while debugging the backend).
---
## Quick Start
### Prerequisites
| Tool | Version | Notes |
|------|---------|-------|
| Go | 1.26+ | Pinned in `go.mod`; do **not** downgrade |
| Node.js | 18+ | LTS recommended |
| Yarn | 1.x | Only package manager allowed (`yarn.lock` is the source of truth) |
| MySQL | 8.0 | `utf8mb4` / `utf8mb4_general_ci` everywhere |
| Redis | 7 | Used for token cache & locks |
| `amz-sdk` | v1.0.0+ | Pulled automatically via `go.mod` — no local checkout needed |
| LLM endpoint | OpenAI-compatible | GPT-5 / GPT-4o / Claude via proxy — anything that speaks the Responses API |
### 1. Clone & install
```bash
# 1) clone main repo
git clone https://github.com/4379711/amz-ad-pilot.git
cd amz-ad-pilot
# 2) install backend deps (fetches github.com/4379711/amz-sdk automatically)
cd amz-ad-pilot-go
go mod download
# 3) install frontend deps
cd ../amz-ad-pilot-vue
yarn install --frozen-lockfile
```
### 2. Initialise the database
Create the database and import the bootstrap script in one shot:
```bash
cd .. # back to the repo root
mysql -u root -p -e "CREATE DATABASE www DEFAULT CHARACTER SET utf8mb4 DEFAULT COLLATE utf8mb4_general_ci;"
mysql -u root -p www < amz-ad-pilot-go/scripts/init.sql
```
`scripts/init.sql` contains everything a fresh instance needs:
- the full schema — 50 tables (`amz_*` business tables + `sys_user`);
- the default login account `admin` / `admin`;
- built-in AI playbooks & guardrails (`amz_ai_agent_skills`);
- category benchmark presets (`amz_category_benchmark`).
> `init.sql` is the full bootstrap for fresh instances; existing instances should apply incremental scripts under `scripts/updates/` in filename order.
### 3. Configure
Copy the example config and fill in your own MySQL / Redis / LLM credentials:
```bash
cd amz-ad-pilot-go/configs
cp config-example.yaml config-dev.yaml
# edit config-dev.yaml: mysql.addr / redis.{addr,pass} / ai.{api-key,model,base-url}
```
> The shipped `config-dev.yaml` / `config-prod.yaml` are placeholders. **Never** commit real credentials. The licence does not waive your responsibility to keep secrets out of source control — please scrub git history if you accidentally commit real keys.
### 4. Run
Terminal A — backend:
```bash
cd amz-ad-pilot-go
go run ./cmd/web
# Web UI: http://127.0.0.1:43000/
```
Terminal B — frontend (dev):
```bash
cd amz-ad-pilot-vue
yarn dev
# Dev UI: http://127.0.0.1:9000/
```
Terminal C — offline data puller (optional, for SP-API pulls):
```bash
cd amz-ad-pilot-go
go run ./cmd/datas
```
### 5. First login & store onboarding
1. **Log in** — open the Web UI with the default account (username: `admin`, password: `admin`) and change the password right away.
2. **Bind your store** — System Settings → Sellers: fill in seller id, marketplace country and the SP-API / Ads API credentials (LwA client id / secret / refresh token, Ads profile id).
3. **Pull data** — start `cmd/datas` (Terminal C above) and let it finish the first sync round: campaigns / ad groups / keywords land within minutes, while ad & SC reports backfill on a schedule. Check Ad Analytics → Optimization Diagnosis for the data-quality traffic light.
4. **Feed unit economics** — AI Autopilot → SKU Cost: enter cost structures so break-even ACOS can be derived per campaign.
5. **Enable AI autopilot (optional)** — AI Autopilot → Strategy Config: create a strategy and **start with Shadow mode**; graduate to Approval / Full only after reviewing the audit trail.
---
## Build & Release
Cross-compile a single binary (frontend embedded) with one command:
```bash
cd amz-ad-pilot-go
./scripts/build.sh # interactive menu
# or non-interactively:
./scripts/build.sh web embed mac # macOS amd64, config embedded
./scripts/build.sh web external linux # Linux amd64, config read from same dir
./scripts/build.sh datas embed windows # cron worker for Windows
```
Output:
| Target | Mode | Binary | Frontend |
|--------|------|--------|----------|
| `web` | `embed` | `myweb` / `myweb.exe` | `//go:embed` Vue dist |
| `api` | `embed` | `myweb` | not bundled |
| `datas`| `embed` | `mydatas` | n/a |
| `*` | `external` | same + `config-prod.yaml` | yaml read from binary dir |
---
## Tech Stack
| Layer | Stack |
|-------|-------|
| Backend HTTP | Go 1.26 · Fiber v2 · Wire · Validator v10 |
| Persistence | MySQL 8 · GORM v1.31 · Redis 7 (go-redis v9) |
| Scheduling | robfig/cron v3 |
| AI | OpenAI-compatible Responses API · auto-compact summariser · prompt-cache aware pricing |
| Amazon APIs | [`github.com/4379711/amz-sdk`](https://github.com/4379711/amz-sdk) (Ads v3, Selling Partner v0/v3, LwA) |
| Frontend | Vue 3.3 · Vite 5 · TypeScript · Element Plus 2.11 · ECharts 6 · Pinia + persistedstate |
| Routing | vite-plugin-pages · vite-plugin-vue-layouts |
| HTTP client | Axios (single instance in `utils/request.ts`) |
| Logging | logrus-style facade in `pkg/logx.go`, rotated via lumberjack |
| Config | viper with build-tag-switched embed / external sources |
---
## Roadmap
- [ ] Versioned schema migrations (currently maintained via `scripts/init.sql` and ordered `scripts/updates/update-*.sql`)
- [ ] Sponsored Brands / Sponsored Display modules
- [ ] Multi-tenant isolation (currently single-tenant by design)
- [ ] Demo business dataset for first-run trial (schema & base seed already ship in `scripts/init.sql`)
- [ ] i18n for the Vue UI (currently zh-CN only)
---
## Contributing
We welcome PRs! Please read [CONTRIBUTING.md](./CONTRIBUTING.md) and our [Code of Conduct](./CODE_OF_CONDUCT.md) before opening an issue or pull request.
Quick checklist:
- New backend modules must follow the **5-file `biz//`** convention (`handler.go`, `service.go`, `model.go`, `params.go`, `wire.go`) and regenerate `wire_gen.go` via `bash amz-ad-pilot-go/scripts/gen_wire.sh`.
- Backend / frontend names must be in **1-to-1 correspondence** (`negative_keyword` ⇄ `negative-keyword`).
- Run `go build ./cmd/web` and `yarn build:dev` locally before opening a PR — CI enforces both.
---
## License
This project is licensed under the [PolyForm Noncommercial License 1.0.0](./LICENSE). You may use, modify and distribute it for any **noncommercial purpose** (personal use, research, education, charities, government institutions, etc.). **Commercial use requires a separate license from the copyright holders.**
Amazon, Sponsored Products, Sponsored Brands, Sponsored Display, Selling Partner and related marks are trademarks of Amazon.com, Inc. or its affiliates. This project is **not** endorsed or sponsored by Amazon.
---
## Disclaimer
This project is provided **as-is**, with no warranty of any kind. Automated bid / budget / keyword changes through the AI Agent can incur real advertising spend on your Amazon accounts. **Always start in Shadow or Approval mode**, review the audit trail under `amz_ai_agent_runs`, and only graduate to Full mode once you trust the agent's behaviour on your category and seller account.