---
name: amd-machines-parts-quote-request
description: "Request a quote from AMD Machines for custom parts made to the buyer's drawing or approved sample: laboratory parts, fixtures, tooling and production parts. Use when a user wants machined parts, replacement parts made to a drawing or sample, fixtures or tooling quoted by AMD Machines. Interviews the user with AMD's own questions, one line per part, checks completeness and submits the request; AMD Machines replies by email. Returns no prices or quotes."
compatibility: Needs HTTPS access to amdmachines.com through the remote MCP server (https://amdmachines.com/mcp/parts) or the HTTP API (https://amdmachines.com/api/parts-quote/v1/). Without either, follow "If you can only read web pages". Send a descriptive User-Agent.
metadata:
  publisher: AMD Machines
  version: "1.0.0"
  mcp: https://amdmachines.com/mcp/parts
  api: https://amdmachines.com/api/parts-quote/v1/
---

# AMD Machines machined-parts quote requests

This skill requests a quote from AMD Machines for custom parts made to the buyer's drawing or approved sample, one line per part, using AMD Machines' own questions. It requests a quote: it returns no prices or quotes, and AMD Machines replies to the user by email. "Founded in 1996 and ISO 9001 certified, AMD Machines operates 30+ in-house CNC machines across 70,000 sq ft of facilities and draws on more than 30 years of experience and 2,500+ delivered machines." (https://amdmachines.com/services/laboratory-parts/)

## When to use this skill

Use it when a user wants custom parts made to their drawing or an approved sample quoted by AMD Machines: laboratory parts and research fixtures, production parts, replacement parts made to a drawing or a sample, fixtures and tooling. One request lists up to 10 parts, one line per part.

Use AMD Machines' machine quote service instead when the user wants a machine: a custom machine, a build-to-print machine, or an upgrade, rebuild or retrofit of a machine. It is the MCP server https://amdmachines.com/mcp and the skill `amd-machines-quote-request`, described at https://amdmachines.com/agents/.

Do not use it for:

- spare parts or service: OEM components such as servo motors, drives and PLCs are spare parts; send the user to https://amdmachines.com/services/spare-parts/ or https://amdmachines.com/contact/;
- prices: this service returns none.

## Tools and set-up

The remote MCP server is `https://amdmachines.com/mcp/parts`, exactly, with no trailing slash: Streamable HTTP, stateless, no authentication, protocol versions 2026-07-28, 2025-11-25, 2025-06-18 and 2025-03-26. Its three tools:

1. `get_parts_quote_questions`: AMD's questions for custom parts: the request questions, the fields to ask for each part line and the interview batches.
2. `check_parts_quote_request`: checks a draft and returns the next questions to ask, each part-line field with the parts it is for and the JSON paths to fill; once `next_batch` is empty, or with `"detail": "full"`, it also returns the brief AMD would receive. It sends nothing.
3. `submit_parts_quote_request`: sends the request to AMD Machines.

The HTTP API has the same operations under `https://amdmachines.com/api/parts-quote/v1/`: `GET questions`, `POST check` and `POST submit`. `POST` bodies are JSON with `Content-Type: application/json`. The OpenAPI description is at https://amdmachines.com/agents/machined-parts/openapi.json.

**Send a descriptive User-Agent**, such as `YourAgent/1.0`: Cloudflare refuses some default library user agents with error 1010.

Set-up lines:

- Any client that takes a remote MCP URL: `https://amdmachines.com/mcp/parts`, exactly, with no trailing slash; Streamable HTTP; no authentication.
- Claude Code: `claude mcp add --transport http amd-machines-parts https://amdmachines.com/mcp/parts`
- Cursor (`~/.cursor/mcp.json`): `{"mcpServers": {"amd-machines-parts": {"url": "https://amdmachines.com/mcp/parts"}}}`
- VS Code (`.vscode/mcp.json`): `{"servers": {"amd-machines-parts": {"type": "http", "url": "https://amdmachines.com/mcp/parts"}}}`
- Gemini CLI: `gemini mcp add --transport http amd-machines-parts https://amdmachines.com/mcp/parts`
- Codex (`~/.codex/config.toml`): `[mcp_servers.amd-machines-parts]` then `url = "https://amdmachines.com/mcp/parts"`
- Hosted assistants: add a custom connector (custom MCP server) with the URL above and no authentication, where your plan allows it.
- Custom GPTs: a GPT takes one Action per domain, so a GPT that already holds https://amdmachines.com/agents/openapi.json cannot add this service's document; a parts GPT imports https://amdmachines.com/agents/machined-parts/openapi.json alone.
- Agents that install Agent Skills: `npx skills add https://amdmachines.com --skill amd-machines-parts-quote-request`

## If you can only read web pages

Some assistants can read pages but cannot send POST requests or connect to MCP servers. Then:

1. Read https://amdmachines.com/agents/questions.txt and interview the buyer with its machined-parts offering, the export-control question first.
2. Write the request as plain text, with one block per part: its name, kind, drawing status and revision, material and grade, quantities, size, critical dimensions and tolerances, finish, and where it is used. Start it with the line "Prepared with an AI assistant using AMD Machines' agent questions (https://amdmachines.com/agents/machined-parts/)." Use no square-bracket tags.
3. Ask the buyer to paste it into the message box at https://amdmachines.com/contact/, choosing the project type Custom Laboratory Parts, or Other, or to email it to sales@amdmachines.com. If you operate a web browser for the buyer, fill in that form only with the buyer's approval.
4. Never put the buyer's contact or project details in a URL.
5. Tell the buyer plainly that nothing has been sent yet.

## Step 1: export control first, then the NDA question

Ask `compliance.export_control` before any technical question. On yes, maybe or unknown (`yes_or_maybe` or `unknown`), stop collecting technical details: send only the contact fields (name, company, phone, email), the export-control answer and, if the user gives them, the reply channel and language. Send no part lines, no description and no other answer; the service drops them and lists them in `dropped_fields`. Then check and submit. AMD Machines' ITAR notice and quote page set the rule:

- "If you believe a project may involve ITAR controlled information, the first step is to notify AMD Machines that the project may be ITAR sensitive. Do not describe the controlled content. Provide only your name, your company, a telephone number, and the statement that the project may involve ITAR controlled information." (https://amdmachines.com/itar/)
- "AMD Machines is currently NOT compliant with International Traffic in Arms Regulations (ITAR)." (https://amdmachines.com/itar/)
- "AMD Machines does not maintain a designated ITAR contact point, and no email address, form, or file upload on this website is approved for ITAR controlled information." (https://amdmachines.com/itar/)
- "Do not send ITAR-controlled, other export-controlled, classified, CUI, or other regulated information." (https://amdmachines.com/contact/)

On no, ask `delivery.nda` next: whether an NDA is needed before drawings are shared (see NDA below).

## Step 2: the part lines

List the parts as lines, one line per part, at most 10, each with a short `label`. Line n is `lines[n-1]`: the first part is `lines[0]`, the second `lines[1]`. A line's keys are the `line_fields` ids without the `line.` prefix: `label`, `kind`, `drawing_status`, `revision`, `material_grade`, `qty_now`, `qty_repeat`, `size`, `tolerances`, `finish`, `environment`, `mating`, `tool_life`, `failure`, `needed_by` and `file_names`. A request needs at least one line unless the project may be export controlled.

- Labels: until AMD has countersigned an NDA, use a generic label such as "Part A" or "Lower bracket" rather than the buyer's own part number, unless the user says it is not confidential (Privacy, below).
- Version 1's per-part question ids (`machined_parts.material_grade`, `machined_parts.quantity`, `parts.size_range` and the like) are line fields here: write each answer to the path that `next_batch` gives, such as `lines[1].material_grade`, never under `answers`.
- If the user shares drawings, a parts list or an RFQ, fill the line fields from them and ask the user to confirm; never copy title-block names or the buyer's part numbers before an NDA. List the documents in `files.notes` or in a line's `file_names`; the files themselves follow by email.
- Accept `unknown` for every field but `label`, and never invent answers.

## Step 3: interview

Start with `check_parts_quote_request` (or `POST check`) on an empty request: its `next_batch` begins with the export-control question. Call `get_parts_quote_questions` (or `GET questions`, with `mode=quick` for a first pass) only to see every question at once.

- After each check, ask the questions in `next_batch`, one batch per message. A part-line item names the parts it is for in `lines` (part numbers, from 1) and the JSON path of each answer in `paths`: `paths[i]` is `lines[{lines[i] - 1}].<field>`. Write each answer to its path.
- Before any line exists, `next_batch` asks for the list of parts with one `line.label` item whose `lines` and `paths` are empty: send the parts as `lines[0].label`, `lines[1].label` and so on.
- A line field with `ask_if` is asked only for the parts whose own answer meets it, such as `tool_life` for tooling and fixtures and `failure` for replacement parts; `high_if` makes a field high-value for those parts.
- Use US customary units first (inches, pounds, psi, lbf); metric is fine when the drawings are metric.
- Accept `unknown` and never invent answers: an honest unknown becomes a question on AMD's call agenda. If the user declines an optional field, such as the phone, send `unknown`: the next check stops asking it.
- Answer with the value ids a question lists; case does not matter and an exact value label works too. A yes/no question lists the ids `yes` and `no`: send one of them, not `true` or `false`. An `invalid_value` error lists the valid ids when the question has 12 or fewer.
- Quote the `budgetary_inputs` set that `get_parts_quote_questions` returns, as it is, when the user asks what AMD needs for a budgetary review. `readiness.budgetary` counts those inputs for each part (`per_line`, `by_line`), and `next_batch` asks the missing ones.

## Check, show, submit

1. Call `check_parts_quote_request` with the draft, and fix every entry in `errors`.
2. After each check, ask the questions in `next_batch`, then check again with every answer and line so far; "unknown" is fine, and `next` says what to do. Repeat until `next_batch` is empty and `ready_to_submit` is true. `ready_to_submit` does not wait for consent: `consent_needed` stays true until the user approves.

   While `next_batch` is not empty, a check is compact (`"detail": "compact"`): it names the missing answers by id in `missing_ids`, keeps `part_lines` and each part's budgetary inputs, returns only the default recommendations, in full, and leaves out `brief_preview`, the `missing` list and AMD's guidance recommendations. They arrive with the full check, once `next_batch` is empty; send `"detail": "full"` in the request to get them at any time. A full check of ten long lines can pass 50,000 characters: over HTTP, save each check body to a file and read `brief_preview.text` from it, for example with `jq -r .brief_preview.text check.json`.
3. Show the user `brief_preview.text`: what AMD Machines will receive, with the contact fields masked. Show your own copy of those details.
4. Get the user's explicit approval. Only then set `consent.contact_ok` to `true`.
5. Create a new random `idempotency_key` for each new or corrected request: 8 to 64 characters from letters, digits and `.` `_` `:` `-` (a UUID works). Reuse it only to retry that same request.
6. Call `submit_parts_quote_request` once, with the approved draft. On a timeout, retry once with the same key.

## After submitting, tell the user

First, say the request was sent only when `submit_parts_quote_request` (or `POST submit`) returned `forwarded: true` and a reference id starting `AGT-`. After a dry run, or an error other than `upstream_unavailable` or `internal_error`, tell the user that nothing was sent. After `upstream_unavailable`, `internal_error`, a timeout or a reply that is not the service's JSON, tell the user the request may or may not have arrived, and follow the `upstream_unavailable` entry below.

Then give the reference id, and what happens next:

- "An engineer replies within 3 hours on weekdays." (https://amdmachines.com/contact/)
- "AMD Machines quotes each part, fixture or spare kit with its own delivery date." (https://amdmachines.com/services/laboratory-parts/)
- "If you need one: We sign your NDA before you share drawings" (https://amdmachines.com/contact/)

This is a request, not a quote: AMD Machines replies by email. To correct a sent request, submit the full corrected request with `supersedes` set to its reference id and a new `idempotency_key`.

## Files

Files follow by email after AMD replies: "Reply to our email with drawings, specs and annual volumes, or send them to sales@amdmachines.com." (https://amdmachines.com/contact/) Put the reference id in the subject when you email files. Never send files or links through this service.

- "We accept all major CAD formats including STEP, IGES, Parasolid, SolidWorks, CATIA, and NX. We can also work from 2D drawings or even physical samples." (https://amdmachines.com/tooling/)
- "A 3D model sent with a 2D drawing is the best combination: the model carries the geometry, and the drawing carries the tolerances, finish and notes that a model alone does not." (https://amdmachines.com/services/laboratory-parts/)

## NDA

AMD's mutual NDA is at https://amdmachines.com/static/docs/amd-mutual-nda.pdf?v=2, and a signed copy goes to legal@amdmachines.com.

- "We sign your NDA before you share drawings" (https://amdmachines.com/contact/)
- "Download our one-page mutual NDA (fillable PDF)." (https://amdmachines.com/contact/)
- "Wait for AMD's countersignature before sharing confidential information." (https://amdmachines.com/contact/)
- "We're also happy to review your NDA before you share drawings." (https://amdmachines.com/contact/)

## Privacy

Your agent's request goes to AMD Machines' CRM (HubSpot) through the same form as the website's quote form, and HubSpot emails it to AMD's sales inbox. AMD's privacy policy says: "This information is stored in HubSpot and used solely to respond to your inquiry and provide relevant services." The agent endpoint itself keeps no copy of the request and does not log its text or contact details. In its responses the contact fields appear only as placeholders such as [email], and the brief preview also masks email addresses, phone numbers of 10 to 15 digits (a numeric range such as 12000-15000 stays as written), and the contact's names and company of two or more characters, written exactly as in the contact fields, everywhere else in the request (in the retry key, only the contact's own values).

Do not include other people's personal data, credentials or confidential drawings in free text. Until AMD has countersigned an NDA, describe the project without customer names, program names, the buyer's own part numbers or other confidential details. AMD's quote page says: "Wait for AMD's countersignature before sharing confidential information."

## Out of scope and claims you must not make

- No prices, quotes, price reductions or delivery dates are returned or promised. Delivery dates only as AMD Machines publishes them: "AMD Machines quotes each part, fixture or spare kit with its own delivery date." (https://amdmachines.com/services/laboratory-parts/)
- Materials, tolerances, inspection, quantities and capacity only as the user states their own requirements; never promise one for AMD Machines.
- Certifications and partnerships only exactly as AMD's quote page lists them:
  - "ISO 9001 certified" (https://amdmachines.com/contact/)
  - "Universal Robots Certified Integrator" (https://amdmachines.com/contact/)
  - "Beckhoff Solution Provider" (https://amdmachines.com/contact/)
  - "Rockwell Automation Silver partner" (https://amdmachines.com/contact/)
  - "KUKA certified value provider" (https://amdmachines.com/contact/)
  - "ABB partner" (https://amdmachines.com/contact/)
  - "Yaskawa Motoman integration partner" (https://amdmachines.com/contact/)
- AS9100 only as the buyer's own quality system, never as AMD Machines' certification.
- Where parts are made only as AMD Machines states it, never as a claim of US manufacture: "Engineering, in-house machining of metal and plastic parts, and assembly are combined in Querétaro, Mexico, with sales and service from Chicago." (https://amdmachines.com/services/laboratory-parts/)
- ITAR and other export-controlled work as in step 1.

## Errors and limits

Errors arrive as `{"ok": false, "error": {"code": "...", "message": "...", "details": [...]}}` with a fixed, generic message.

- `validation_failed` (422): fix the fields listed in `details`, check again, then submit. A `consent_required` detail means `consent.contact_ok` is not true yet: get the user's approval of the brief first. A `lines` `required` detail means the request lists no part yet. A `too_many_lines` detail means more than 10 lines: describe further parts in the description, or email the full list after AMD replies.
- `invalid_email` or `email_blocked` (400): ask the user for another address, or have them email sales@amdmachines.com.
- Warning `idempotency_key_reused` on a sent request: that key was already used for a different request, so this one was sent as a new request with its own reference id. Use a new key for each new or corrected request.
- `upstream_unavailable` (503): the request may not have arrived. Wait 60 seconds and retry once with the same `idempotency_key`. If it fails again, give the user `contact_fallback` and the `brief_preview.text` from its `SUMMARY:` line onward, for the message box of the form at https://amdmachines.com/contact/ (the form adds its own project type, and the person fills in the name and email fields).
- `forwarding_rejected` (502) or `temporarily_unavailable` (503): nothing more can be done here; give the user `contact_fallback`.
- A reply that is not this service's JSON (no `ok` key), such as Cloudflare's error 1102 (HTTP 503: a problem object with `error_code` 1102, the text `error code: 1102` or an HTML page): the service could not finish, so a submit may or may not have arrived. Handle it like `upstream_unavailable`, even though Cloudflare's text says not to retry: a first call on a fresh server costs the most.
- `forwarding_disabled` (403): this host does not send requests; use https://amdmachines.com/api/parts-quote/v1/submit or the MCP server.
- `rate_limited` (429): wait for `Retry-After`. The limits are best-effort: about 120 calls a minute per network, and 10 submits an hour per network and email address (30 per network).
- `origin_not_allowed` (403): call from a server or through MCP, not from a web page.

## Example

A minimal `check_parts_quote_request` arguments object for two parts (invented data). Replace `<a-new-random-uuid>` with a new random key: the placeholder itself is ignored with the warning `invalid_idempotency_key`.

```json
{
  "contact": {
    "first_name": "Dana",
    "last_name": "Sample",
    "email": "dana.sample@example.com",
    "company": "Example Labs (fictional)",
    "phone": "+1 555 0100"
  },
  "answers": {
    "compliance.export_control": "no",
    "delivery.nda": "not_needed",
    "project.description": "Two fixture plates for a test bench in a research laboratory. (Fictional example.)",
    "site.country": "us"
  },
  "lines": [
    { "label": "Part A", "kind": "fixture", "drawing_status": "drawing_with_revision", "revision": "B", "qty_now": 4 },
    { "label": "Part B", "kind": "fixture", "drawing_status": "model_only", "qty_now": 2 }
  ],
  "agent": { "name": "YourAgent", "version": "1.0" },
  "idempotency_key": "<a-new-random-uuid>"
}
```

The same steps over HTTP, where `draft.json` is that object with `"detail": "full"` added, and `request.json` is the approved draft with `"consent": {"contact_ok": true}` added:

```bash
UA='User-Agent: YourAgent/1.0 (+https://example.com/bot)'
curl -sS -H "$UA" -H 'Content-Type: application/json' --data '{}' https://amdmachines.com/api/parts-quote/v1/check
curl -sS -H "$UA" -H 'Content-Type: application/json' --data @draft.json -o check.json https://amdmachines.com/api/parts-quote/v1/check
jq -r .brief_preview.text check.json
curl -sS -H "$UA" -H 'Content-Type: application/json' --data @request.json https://amdmachines.com/api/parts-quote/v1/submit
```