Power your agent
Instal dari penerbit. Bukan endpoint PlugMCP.
URL remote atau perintah di mesin Anda? Perbedaan kedua cara instal
Jalankan di PlugMCP
A new server you create. It is not this listing's official endpoint. Use the publisher install when you want their URL and their credentials.
BukaThe most complete open-source MCP server and CLI for Shopify. 62 built-in tools + 2 custom tool examples across 5 domains — use it as an MCP server for AI agents (Claude, Cursor, Windsurf) or as a standalone CLI to manage Shopify stores directly from your terminal.
cob-shopify products list --limit 5, orders get --id ..., etc.)api: storefront on a custom
tool, for the objects that exist on one schema only (Shop.brand — the merchant's logo and
brand colours — has no Admin equivalent). The Storefront token is minted automatically from
your Admin credentials, because a client-credentials app has no token page in the Shopify admin
to copy one fromThis project gives you two ways to interact with Shopify. Same tools, same engine, same auth — different interfaces.
You don't have to choose — install once, use both:
# CLI — run directly from terminal
cob-shopify products list --limit 5
cob-shopify products list --limit 5 --fields id,title,status
cob-shopify orders get --id gid://shopify/Order/123 --json
# MCP — connect to Claude and let AI use the same tools
claude mcp add cob-shopify-mcp -- cob-shopify-mcp start
Every MCP server on GitHub dumps all tool schemas into the AI's context on connect. With 62 tools, that's ~19,000 tokens consumed before the user even asks a question. Most conversations use 1-2 tools — 95% of those tokens are wasted.
Advertise-and-Activate fixes this. Instead of loading all 62 tool schemas, the server registers a single activate_tools meta-tool with a lightweight domain summary:
Before (default): 62 tool schemas → ~19,000 tokens per prompt
After (activate): 1 meta-tool → ~300 tokens per prompt
On-demand: AI activates 1 domain → +2,000-3,000 tokens only when needed
How it works:
activate_tools with a description listing all domains and their tool countsactivate_tools("analytics") — server dynamically registers 16 analytics toolstop_products as normalTypical conversation: ~2,800 tokens instead of ~19,000. That's an 82% reduction.
No competitor Shopify MCP server has this. It requires clean domain grouping, a dynamic registry, and a meta-tool pattern — all built into this server's architecture.
Enable it:
# cob-shopify-mcp.config.yaml
tools:
advertise_and_activate: true
Or via environment variable:
COB_SHOPIFY_ADVERTISE_AND_ACTIVATE=true
Custom YAML tools are included automatically — they declare a domain and appear in the corresponding summary.
AI agents like Claude Code and Cursor have built-in terminal access. That means they can run CLI commands directly — no MCP server needed, no config required:
# AI agent runs this via its Bash tool — zero setup
cob-shopify products list --limit 5 --json
cob-shopify orders get-by-name --name "#1001" --json
cob-shopify analytics sales-summary --start_date 2026-01-01 --end_date 2026-03-15 --json
Every command outputs clean JSON when piped or when --json is passed. The AI reads the output and uses the data. The --schema flag lets the AI discover what inputs any command accepts:
cob-shopify products list --schema # AI reads the schema, knows what flags to pass
No MCP connection, no server process, no protocol overhead. Just npm install -g cob-shopify-mcp and the AI can use every tool immediately.
You don't have to choose — install once, use both. Same tools, same engine, same Shopify API.
flowchart LR
subgraph AGENTS["Your AI Layer"]
direction TB
SALES["Sales Assistant"]
SUPPORT["Customer Support Bot"]
WAREHOUSE["Warehouse Manager"]
SHIPPING["Shipping Tracker"]
BI["Business Intelligence"]
AUTO["Automation Workflows"]
end
MCP["cob-shopify-mcp\n62 tools · 4 resources · 4 prompts\nAdvertise-and-Activate: 82% less context"]
SHOPIFY["Shopify Store"]
AGENTS --> MCP --> SHOPIFY
1. Direct MCP (simplest) — Claude, Cursor, or any MCP client connects directly:
AI Agent → MCP Protocol → cob-shopify-mcp → Shopify API
2. Agent Orchestration Layer — Your custom agent framework uses MCP as the Shopify bridge:
User → Your App → Agent Layer (LangChain, CrewAI, etc.) → MCP Client → cob-shopify-mcp → Shopify API
3. RAG + MCP — Combine retrieval-augmented generation with live Shopify data:
User → Your App → RAG (product docs, policies, FAQs) + MCP (live store data) → Response
4. Multi-Agent System — Multiple specialized agents share one MCP server:
Sales Agent ─┐
Support Agent ─┤→ cob-shopify-mcp (HTTP transport) → Shopify API
Warehouse Agent─┘
Binary names:
cob-shopifyfor CLI use,cob-shopify-mcpfor MCP server setup. Same binary, two names.
First: Complete Getting Shopify Credentials below to get your Client ID, Client Secret, and store domain. Then come back here.
Pick one of the three paths below. All get you to the same result — a working MCP server connected to Claude.
Install globally and connect in two commands. No .env file needed — credentials go straight into the Claude config.
npm install -g cob-shopify-mcp
Connect to Claude CLI:
claude mcp add cob-shopify-mcp \
-e SHOPIFY_CLIENT_ID=your_client_id \
-e SHOPIFY_CLIENT_SECRET=shpss_your_secret \
-e SHOPIFY_STORE_DOMAIN=your-store.myshopify.com \
-- cob-shopify-mcp start
Done. Claude launches the server automatically when needed. Verify:
claude mcp list
# cob-shopify-mcp: ... - ✓ Connected
Or with npx (no install at all):
claude mcp add cob-shopify-mcp \
-e SHOPIFY_CLIENT_ID=your_client_id \
-e SHOPIFY_CLIENT_SECRET=shpss_your_secret \
-e SHOPIFY_STORE_DOMAIN=your-store.myshopify.com \
-- npx cob-shopify-mcp start
Or connect to Claude Desktop — add to claude_desktop_config.json (file location):
{
"mcpServers": {
"cob-shopify-mcp": {
"command": "cob-shopify-mcp",
"args": ["start"],
"env": {
"SHOPIFY_CLIENT_ID": "your_client_id",
"SHOPIFY_CLIENT_SECRET": "shpss_your_secret",
"SHOPIFY_STORE_DOMAIN": "your-store.myshopify.com"
}
}
}
}
Restart Claude Desktop after saving. You'll see the tools icon showing 62 available tools.
Clone the repo and build from source. Claude launches the server via stdio — you don't run it yourself.
B1. Clone and build:
git clone https://github.com/svinpeace/cob-shopify-mcp.git
cd cob-shopify-mcp
pnpm install
pnpm build
B2. Connect to Claude CLI:
claude mcp add cob-shopify-mcp \
-e SHOPIFY_CLIENT_ID=your_client_id \
-e SHOPIFY_CLIENT_SECRET=shpss_your_secret \
-e SHOPIFY_STORE_DOMAIN=your-store.myshopify.com \
-- node /absolute/path/to/cob-shopify-mcp/dist/cli/index.js start
Done. Verify:
claude mcp list
# cob-shopify-mcp: ... - ✓ Connected
Or connect to Claude Desktop — add to claude_desktop_config.json (file location):
{
"mcpServers": {
"cob-shopify-mcp": {
"command": "node",
"args": ["/absolute/path/to/cob-shopify-mcp/dist/cli/index.js", "start"],
"env": {
"SHOPIFY_CLIENT_ID": "your_client_id",
"SHOPIFY_CLIENT_SECRET": "shpss_your_secret",
"SHOPIFY_STORE_DOMAIN": "your-store.myshopify.com"
}
}
}
}
Run the server as a container via HTTP transport. Good for always-on setups, VPS deployments, or shared team access.
C1. Clone and configure:
git clone https://github.com/svinpeace/cob-shopify-mcp.git
cd cob-shopify-mcp
cp .env.example .env
Edit .env with your credentials:
SHOPIFY_CLIENT_ID=your_client_id
SHOPIFY_CLIENT_SECRET=shpss_your_secret
SHOPIFY_STORE_DOMAIN=your-store.myshopify.com
C2. Build and start the container:
docker compose up --build
# Server starts at http://127.0.0.1:3000
Verify it's running:
curl http://127.0.0.1:3000/health
# {"status":"ok"}
C3. Connect to Claude CLI:
claude mcp add --transport http shopify http://127.0.0.1:3000
# Verify
claude mcp list
# cob-shopify-mcp: http://127.0.0.1:3000 (HTTP) - ✓ Connected
Or connect to Claude Desktop — add to claude_desktop_config.json (file location):
{
"mcpServers": {
"cob-shopify-mcp": {
"url": "http://127.0.0.1:3000"
}
}
}
Windows note: Use
127.0.0.1notlocalhost— Docker on Windows may not bind to IPv6::1whichlocalhostcan resolve to.
Claude Desktop config file location:
Everything happens through the Shopify Developer Dashboard at dev.shopify.com. You need two things: a dev store (free) and an app with the right scopes.
You need a store to test against. Dev stores are free and never expire.
my-dev-store) — this becomes my-dev-store.myshopify.comNote your store domain — you'll need it:
my-dev-store.myshopify.com
Click Apps in the left sidebar
Click Create app (top-right)
Enter an app name (e.g., Shopify MCP Server) and click Next
You'll land on the version configuration page
Scroll down to the Access section
Click Select scopes — this opens a dropdown where you can either:
Full access (recommended — copy-paste this entire block):
read_products, write_products, read_orders, write_orders, read_all_orders, read_draft_orders, write_draft_orders, read_order_edits, write_order_edits, read_customers, write_customers, read_inventory, write_inventory, read_locations, read_fulfillments, write_fulfillments, read_assigned_fulfillment_orders, write_assigned_fulfillment_orders, read_merchant_managed_fulfillment_orders, write_merchant_managed_fulfillment_orders, read_third_party_fulfillment_orders, write_third_party_fulfillment_orders, read_shipping, read_reports, read_legal_policies
Read-only? Use only the read scopes and set
COB_SHOPIFY_READ_ONLY=truein.env:read_products, read_orders, read_all_orders, read_draft_orders, read_customers, read_inventory, read_locations, read_fulfillments, read_assigned_fulfillment_orders, read_merchant_managed_fulfillment_orders, read_third_party_fulfillment_orders, read_shipping, read_reports, read_legal_policies
What each scope enables:
For even more scopes (themes, discounts, metafields, gift cards, marketing, returns, etc.) for custom YAML tools, see the Custom Tools Guide.
shpss_).envcp .env.example .env
Fill in your credentials:
SHOPIFY_CLIENT_ID=your_client_id_here
SHOPIFY_CLIENT_SECRET=shpss_your_secret_here
SHOPIFY_STORE_DOMAIN=my-dev-store.myshopify.com
SHOPIFY_API_VERSION=2026-01
The server uses client credentials auth — it automatically exchanges your Client ID + Secret for a 24-hour access token, and refreshes it before it expires. No manual token management needed.
Alternative: Static access token. If you already have a
shpat_token (from Shopify CLI, a custom app, or another source), you can use that instead:SHOPIFY_ACCESS_TOKEN=shpat_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx SHOPIFY_STORE_DOMAIN=my-dev-store.myshopify.comWhen
SHOPIFY_ACCESS_TOKENis set, the server uses it directly and ignores Client ID/Secret.
Done. Proceed to Quick Start to run the server.
Create cob-shopify-mcp.config.yaml in your project root:
auth:
method: token # token | client-credentials | authorization-code
store_domain: ${SHOPIFY_STORE_DOMAIN}
access_token: ${SHOPIFY_ACCESS_TOKEN}
shopify:
api_version: "2026-01"
cache:
read_ttl: 30 # seconds
search_ttl: 10
analytics_ttl: 300
tools:
read_only: false # disable all mutations
disable: [] # tool names to disable
enable: [] # tool names to force-enable (even tier 2)
advertise_and_activate: false # lazy tool loading — 82% less context tokens
transport:
type: stdio # stdio | http
port: 3000
host: "0.0.0.0"
storage:
backend: json # json | sqlite
path: "~/.cob-shopify-mcp/"
observability:
log_level: info # debug | info | warn | error
audit_log: true
rate_limit:
respect_shopify_cost: true
max_concurrent: 10
defaults < config file < environment variables < CLI flags
auth.method is inferred as client-credentials when client_id and client_secret are set
and no access_token is — but only when no layer declared a method. The authorization-code
flow needs those same credentials, so set SHOPIFY_AUTH_METHOD=authorization-code (or
auth.method in the config file) to use it; an explicit value is never overridden.
# Natural commands — cob-shopify <domain> <action> [flags]
cob-shopify products list --limit 5
cob-shopify products list --limit 5 --fields id,title,status
cob-shopify products get --id gid://shopify/Product/123
cob-shopify products search --query "snowboard" --limit 10
cob-shopify orders list --limit 10 --json
cob-shopify orders get --id gid://shopify/Order/456 --fields id,name
cob-shopify customers search --query "email:[email protected]"
cob-shopify inventory low-stock-report --threshold 10
cob-shopify analytics sales-summary --start_date 2025-01-01 --end_date 2025-12-31
# Global flags (available on every command)
--json # Force JSON output (auto when piped)
--fields <f1,f2> # Select specific response fields
--jq <expr> # Filter JSON with jq expression
--schema # Show command schema, don't execute
--dry-run # Preview mutations without executing
--yes # Skip confirmation prompts
# Schema introspection (for AI agents)
cob-shopify products list --schema
# Mutation safety
cob-shopify products create --title "New Widget" --dry-run
cob-shopify products delete --id gid://shopify/Product/123 # prompts for confirmation
# Server commands
cob-shopify-mcp start # Start the MCP server
cob-shopify-mcp start --transport http --port 8080
cob-shopify connect --store my-store.myshopify.com
cob-shopify connect # --store is optional; falls back to the configured store
cob-shopify config show
# Legacy commands (deprecated, will be removed in v1.0)
cob-shopify tools list
cob-shopify tools info list_products
All analytics tools use ShopifyQL — single API call per query, no cursor pagination.
Add to .cursor/mcp.json or equivalent:
{
"mcpServers": {
"cob-shopify-mcp": {
"command": "npx",
"args": ["-y", "cob-shopify-mcp", "start"],
"env": {
"SHOPIFY_CLIENT_ID": "your_client_id",
"SHOPIFY_CLIENT_SECRET": "shpss_your_secret",
"SHOPIFY_STORE_DOMAIN": "your-store.myshopify.com"
}
}
}
}
pnpm install
pnpm test # Unit tests only — no network, no .env needed
pnpm test:integration # Everything, incl. live tests against a real store (loads .env)
pnpm lint # Biome linter
pnpm typecheck # TypeScript type checking
pnpm build # Build with tsup
Live tests are gated on credentials and skip cleanly without them. Put either auth method in
.env (gitignored) — client credentials are enough, no separate access token required:
SHOPIFY_STORE_DOMAIN=your-dev-store.myshopify.com
SHOPIFY_CLIENT_ID=xxxxxxxxxxxx
SHOPIFY_CLIENT_SECRET=xxxxxxxxxxxx
# ...or a static token instead, which takes precedence if both are present:
# SHOPIFY_ACCESS_TOKEN=shpat_xxxxxxxxxxxx
The app needs all 13 scopes the tools use — read_reports in particular, or every ShopifyQL
analytics tool fails:
read_products, write_products, read_orders, write_orders, write_draft_orders,
read_customers, write_customers, read_inventory, write_inventory, read_locations,
read_assigned_fulfillment_orders, write_assigned_fulfillment_orders, read_reports
A fresh dev store has no data, so analytics assertions will be vacuous — node scripts/create-test-orders.js
seeds it first.
pnpm testdeliberately does not load.env: the unit suite stays hermetic. That means live tests always skip there, by design. Usepnpm test:integrationto actually exercise a store.
Animated, interactive diagram showing how Entry Points, Core Engine, Shopify Shell, and the GraphQL API connect
flowchart TB
subgraph ENTRY["Entry Points"]
direction LR
CLI["CLI\nproducts · orders · customers\ninventory · analytics"]
STDIO["MCP Server\nstdio transport"]
HTTP["HTTP Server\nStreamable HTTP"]
end
subgraph CORE["Core Engine (API-Agnostic)"]
direction TB
subgraph REGISTRY["Registry & Discovery"]
direction LR
AD["Auto-Discover\n*.tool.ts"]
REG["Tool Registry\nregister · list · filter"]
CF["Config Filter\nenable · disable · tiers"]
end
subgraph ENGINES["MCP Engines"]
direction LR
TE["Tool Engine\nschema gen · execute"]
RE["Resource Engine\nread-only data"]
PE["Prompt Engine\ntemplates · workflows"]
end
subgraph INFRA["Infrastructure"]
direction LR
AUTH["Auth Manager\nstatic · client-creds · OAuth"]
OBS["Observability\nlogs · metrics · audit"]
STORE["Storage\nJSON · SQLite+encryption"]
end
DT["defineTool() Helper"]
end
subgraph SHOPIFY["Shopify Shell"]
direction TB
subgraph CLIENT["Shopify GraphQL Client"]
direction LR
GQL["GraphQL Client\n@shopify/admin-api-client"]
RL["Rate Limiter"]
CACHE["Cache Layer"]
end
subgraph TOOLS["62 Tool Definitions"]
direction LR
PROD["Products\n15 tools"]
ORD["Orders\n12 tools"]
CUST["Customers\n9 tools"]
INV["Inventory\n7 tools"]
ANAL["Analytics\n16 tools"]
end
subgraph MCPPRIM["MCP Primitives"]
direction LR
RES["Resources\nshop info · locations"]
PROMPT["Prompts\nstore health · reports"]
end
end
SHOPIFY_API["Shopify Admin GraphQL API"]
CLI --> CORE
STDIO --> CORE
HTTP --> CORE
AD --> REG
REG --> CF
CF --> TE
CF --> RE
CF --> PE
DT -.-> REG
TE --> CLIENT
RE --> CLIENT
PE --> CLIENT
AUTH --> CLIENT
OBS -.-> TE
STORE -.-> AUTH
GQL --> RL
RL --> CACHE
TOOLS --> DT
MCPPRIM --> RE
MCPPRIM --> PE
CACHE --> SHOPIFY_API
src/
├── core/ # API-agnostic MCP server core
│ ├── config/ # Zod config schema, multi-source loader
│ ├── auth/ # Static token, client credentials, OAuth
│ ├── engine/ # Tool, Resource, Prompt execution engines
│ ├── registry/ # Tool registry with config filtering
│ ├── storage/ # JSON + SQLite backends with encryption
│ ├── transport/ # stdio + HTTP transports
│ ├── observability/ # pino logger, cost tracker, audit log
│ └── helpers/ # defineTool, defineResource, definePrompt
├── shopify/ # Shopify-specific implementation
│ ├── client/ # GraphQL client, rate limiter, cache, retry
│ ├── tools/ # 62 tools across 5 domains
│ ├── resources/ # 4 MCP resources
│ └── prompts/ # 4 MCP prompts
├── server/ # Server bootstrap and registration bridges
└── cli/ # CLI commands (Commander + consola)
61 tools ship enabled out of the box (all Tier 1; the 62nd, shopifyql_query, is Tier 2 and opt-in) — but the tool count is unlimited. Developers can add any Shopify GraphQL operation as a custom tool using simple YAML files, no TypeScript required:
# my-tools/get-metafields.yaml
name: get_shop_metafields
domain: shop
description: Get shop metafields by namespace
scopes: [read_metafields]
input:
namespace:
type: string
description: Metafield namespace
required: true
graphql: |
query($namespace: String!) {
shop {
metafields(first: 10, namespace: $namespace) {
edges { node { key value } }
}
}
}
response:
mapping: shop.metafields.edges
Point your config at the directory and they're live:
tools:
custom_paths: ["./my-tools/"]
The 3-tier system gives full control: Tier 1 (enabled by default), Tier 2 (disabled by default, opt-in via config), Tier 3 (custom YAML tools, enabled by default). Plus tools.enable / tools.disable for granular overrides.
See the Custom Tools Guide for the full reference — YAML structure, variable naming rules, response mapping, scopes reference, error handling, and step-by-step examples.
The package ships with 5 ready-to-use custom tools in custom-tools/ — draft order completion, fulfillment orders, create fulfillment with tracking, update tracking, and order cancellation. They're enabled by default in .env.example (COB_SHOPIFY_CUSTOM_TOOLS=./custom-tools). To disable them, remove or comment out that line.
# Via environment variables
COB_SHOPIFY_CUSTOM_TOOLS=./custom-tools # Load custom YAML tools from directory
COB_SHOPIFY_DISABLE=cancel_order,tool2 # Disable specific tools
COB_SHOPIFY_ENABLE=some_tier2_tool # Enable specific Tier 2 tools
COB_SHOPIFY_READ_ONLY=true # Disable ALL write operations
Any Shopify GraphQL query or mutation can become a tool without writing TypeScript: drop a .yaml
file in a directory and point custom_paths (or COB_SHOPIFY_CUSTOM_TOOLS) at it. Admin is the
default; since 0.10.0 a tool can declare api: storefront and reach the Storefront API
instead — see Talking to the Storefront API.
Input fields declare a type, and the vocabulary is:
array and object arrived in 0.8.0. They are what let a tool take a list — choosing which
lines go in a fulfillment, for instance:
input:
line_items:
type: array
required: false
min: 1 # an empty list is refused, not read as "all of them"
items:
type: object
properties:
id:
type: string
required: true
quantity:
type: number
required: true
Two things are worth knowing before you reach for them:
[] means "none". For
fulfillmentCreate those two readings differ by the whole order — omitted fulfils everything
remaining. Use min: 1 when an empty list must be refused rather than interpreted.properties:
never reaches Shopify. If a variable appears to be ignored, check that every field of it is
declared.Shopify has two GraphQL APIs, and a few things live on only one of them. Shop.brand — the
merchant's uploaded logo, square logo, cover image and brand colours — is Storefront-only and has
no Admin equivalent, so before 0.10.0 no tool in this package could reach it: the query
loaded, the server booted, the connection reported healthy, and the call failed with
Field 'brand' doesn't exist on type 'Shop'.
Declare the API on the tool. admin is the default and what every tool written before 0.10.0 is:
name: get_shop_brand
domain: shop
description: The merchant's logo and brand colours
api: storefront
input: {}
graphql: |
query {
shop {
brand {
logo { image { url } }
squareLogo { image { url } }
}
}
}
The token is minted for you. An app installed with client credentials has no Storefront token
page anywhere in the Shopify admin — that panel belongs to admin-created custom apps — so there is
usually nothing to paste even if you want to. storefrontAccessTokenCreate is an Admin
mutation, so this package creates the token from the credentials it already has, reusing an
existing one where the store has it. Nothing is requested until a api: storefront tool actually
runs.
To supply your own instead, set auth.storefront_access_token or
SHOPIFY_STOREFRONT_ACCESS_TOKEN.
What a Storefront token may read comes from the app's
unauthenticated_*scopes, which are separate from its Admin ones. An app with fifty Admin scopes and none of these mints a token successfully and then reads nothing. Shop-level content generally wantsunauthenticated_read_content. Add it to the app's release and re-install the app — a client-credentials app picks up new scopes only on re-authorisation.
0.9.0 turned two mistakes from silent runtime behaviour into a refusal at load time. Both used to produce a tool that registered, reported healthy, and did the wrong thing when called.
A type: the loader does not implement is refused. It used to fall through to string, so
type: integer quietly became a string field — 5 was rejected and "5" was sent to Shopify as
text. The error names the field, including nested ones:
YAML tool "my_tool" at "./my-tools/thing.yaml": input "lines.items.quantity" has unknown
type "integer". Valid types: string, number, boolean, enum, array, object
input: and your GraphQL variables must be the same set, in both directions. A YAML tool has
no handler — the engine runs your document with the validated input as its variables and nothing
else — so any difference between the two is a bug you cannot see:
input: declares can never be supplied, and GraphQL reads an absent optional
variable as "not specified";input: no variable uses is validated and then dropped, so the tool advertises a parameter
it ignores.One typo causes both. The complete_draft_order tool shipped with payment_pending in its input
and $paymentPending in its mutation, so asking for a pending payment completed the draft order
as paid — with no error anywhere. It is fixed in 0.9.0, and the loader now refuses that shape.
A $ inside a string literal, a # comment or a """ block is not read as a variable, so
query: "price:>$100" is fine.
Full guide, including the scopes reference → Custom Tools Guide
This server manages your store via the Admin GraphQL API. Pair it with Shopify's official MCP servers for the complete experience:
See the full changelog here → CHANGELOG.md
Built by Call O Buzz Services — AI-driven software development, SaaS solutions, and open source tools.
MIT
Production-grade MCP server and CLI tool for Shopify Admin GraphQL API — 49+ tools, YAML-extensible, dual auth, dual transport, Docker-ready
Tool
Belum ada daftar tool. Server remote mendapatkannya setelah pemeriksaan kesehatan pertama.
FAQ
Salin konfigurasi stdio untuk Cursor, Claude Desktop, Claude Code, atau VS Code di halaman ini. Konfigurasi ini memakai instalasi dari penerbit, bukan proxy PlugMCP.
Tidak ada variabel lingkungan wajib yang tercantum di catatan ini.
Cob Shopify berjalan secara lokal melalui stdio.
Terakhir diperiksa 2026-10-27. Production-grade MCP server and CLI tool for Shopify Admin GraphQL API — 49+ tools, YAML-extensible, dual auth, dual transport, Docker-ready