E-commerce Fashion Market Analysis

Fashion intelligence MCP server for AI agents.

SEO audits, trend analysis, DTC demand forecasting, CRM enrichment, and campaign creative — built for Claude Code, Cursor, Codex, and any MCP-compatible agent.

Overview • Quick Start • Tools • Examples • Architecture • Skill Pack • Configuration

Overview

E-commerce Fashion Market Analysis is a vertical MCP server that gives your AI agent specialized fashion intelligence: SEO auditing, trend research, DTC demand forecasting, CRM segment enrichment, and campaign creative generation. It runs locally via stdio — no cloud deployment required.

Built by alexgenovese.com for fashion brands, agencies, and creators.

What it does

Why it's different

• This server needs no API keys. product_seo_audit, dtc_forecast_analysis, category_demand_outlook, customer_trend_enrichment, and campaign_theme_recommendation all work with data you provide directly. Only fashion_trend_analysis needs upstream search data, which comes from the separate Tavily MCP server (install it alongside and set TAVILY_API_KEY there — not here). Provider integrations (Shopify, Klaviyo, Meta Ads, etc.) are optional and read their own env vars when enabled.

• Explainable outputs. Every tool returns assumptions[], dataGaps[], confidence, and recommendedNextCalls[] — your agent always knows what it's missing.

• Write-back is opt-in. Default dry_run: true. PII filtering on every write-back. Forecasts use aggregated segments, never personal profiles.

• Local SQLite persistence. Zero-config (~/.fashion-mcp/store.db) for snapshots, TTL cache, feature store, and forecast actuals for backtesting.

• Tool-agnostic skill pack. 16 playbooks use ~~category placeholders so they work with any MCP server in that category (swap Shopify for WooCommerce without touching the skill).

Related MCP server: Gadget MCP Server

Quick Start

Install

git clone https://github.com/alexgenovese/ecommerce-fashion-market-analysis.git
cd ecommerce-fashion-market-analysis
npm install
npm run build

Connect to your AI agent

claude mcp add fashion -- node /path/to/ecommerce-fashion-market-analysis/dist/index.js

Then in chat:

Run a product SEO audit on "Black Leather Jacket" — url: https://mystore.com/products/black-leather-jacket, category: Outerwear, brand: Acne Studios

Add to .cursor/mcp.json:

{
  "mcpServers": {
    "fashion": {
      "command": "node",
      "args": ["/path/to/ecommerce-fashion-market-analysis/dist/index.js"]
    }
  }
}

Add to your agent's MCP config:

{
  "mcpServers": {
    "fashion": {
      "command": "node",
      "args": ["/path/to/ecommerce-fashion-market-analysis/dist/index.js"]
    }
  }
}

Add to ~/.config/opencode/opencode.json or the project's opencode.json:

{
  "mcp": {
    "fashion": {
      "type": "local",
      "command": ["node", "/path/to/ecommerce-fashion-market-analysis/dist/index.js"],
      "enabled": true
    }
  }
}

Then restart opencode for the changes to take effect.

Add to your VS Code settings.json (Cmd+Shift+P → "Preferences: Open User Settings (JSON)"):

{
  "github.copilot.mcpServers": {
    "fashion": {
      "command": "node",
      "args": ["/path/to/ecommerce-fashion-market-analysis/dist/index.js"]
    }
  }
}

Add to your ~/.continue/config.json:

{
  "experimental": {
    "mcpServers": {
      "fashion": {
        "command": "node",
        "args": ["/path/to/ecommerce-fashion-market-analysis/dist/index.js"]
      }
    }
  }
}

Connect directly without cloning:

{
  "mcpServers": {
    "fashion": {
      "url": "https://ecommerce-fashion-market-analysis--alexgenovese.run.tools"
    }
  }
}

Tools

The server exposes 6 tools. All accept verbose (0/1/2), max_words, and format (json | markdown) for cost control and output shaping. All return explainability blocks (assumptions, dataGaps, recommendedNextCalls).

product_seo_audit

Full SEO audit of a fashion product page. Returns a score (0-100) across 5 dimensions with actionable, role-specific recommendations.

Checks: meta title length, meta description, Product JSON-LD schema completeness, image alt text, URL structure, H1 presence, fashion keywords (size, fit, material, color), seasonal context, canonical URL, hreflang, Open Graph, Twitter Cards, title/URL/H1/schema mismatch.

Output: productTitle, score, dimensionScores (metadata, schema, content, images, fashion_relevance), checks[], recommendations[], structuredData, images[], team_actions[], assumptions[], dataGaps[], recommendedNextCalls[]

fashion_trend_analysis

Structured trend intelligence from Tavily MCP search data. Accepts results from tavily_search, tavily_search_dedup, and tavily_social_media_search — extracts trending keywords, colors, silhouettes, price tiers, market fit, and key insights.

Output: category, season, market, generatedAt, trendingKeywords[] (with stage, confidence, evidence), trendingColors[] (with hex), silhouettes[] (rising/peaking/declining/stable), priceRanges[], marketFit (0-100), priceTierOpportunity[], keyInsights[], assumptions[], dataGaps[], recommendedNextCalls[], warnings[]

dtc_forecast_analysis

Weighted-rule demand forecast for DTC fashion brands. Combines a seasonal baseline with five explainable multipliers to produce a forecast score, confidence interval, driver contributions, risks, and scenario projections.

Forecast formula:

forecast = baseline × trend × media_efficiency × retention × inventory × seasonality

Output: schemaVersion, data → baselineDemand, forecastScore, confidenceInterval (low/high, ±20%), drivers[] (name, contribution %, explanation), risks[], scenarios[] (base/upside/downside)

category_demand_outlook

Lightweight demand snapshot by category — direction, top trend drivers, price tier winners, and inventory risk flags. Faster and cheaper than a full forecast.

Output: schemaVersion, data → demandPulse (0-100), direction (up/down/stable), topDrivers[], priceTierWinners[], inventoryRiskFlags[]

customer_trend_enrichment

Enrich CRM customer segments with trend awareness. Maps trending keywords, colors, and silhouettes onto a segment profile and produces audience clusters with propensity scoring and a CRM-ready campaign message.

Output: schemaVersion, enrichedProfile, audienceClusters[] (name, propensity, recommendedAction), crmReadyMessage

campaign_theme_recommendation

Generate campaign themes for fashion brands with platform-specific copy, hooks, value propositions, and creative briefs grounded in trend data.

Output: schemaVersion, valueProposition, platformSpecific (format/tone/CTA), themeOptions[] (hooks, angles), creativeBrief (visual direction, copy angle, hashtags)

Examples

1. Product SEO Audit

Ask your AI agent:

Audit "Linen Blend Midi Dress" — price: $189, category: Dresses, brand: Mango, material: linen, color: cream. We're launching this for Summer 2025.

What happens: The tool checks meta title length (30-60 chars), meta description (120-158 chars), Product schema completeness, fashion keyword coverage, seasonal alignment, canonical, Open Graph, and Twitter Cards. Returns a score, 5 dimension scores, and prioritized fixes with role-specific team actions.

2. Trend Research for Seasonal Buying

Ask your AI agent:

What denim trends should I stock for this Fall? I run a contemporary denim brand.

What happens: The AI agent calls Tavily MCP (tavily_search) to get real web data, then passes the results to fashion_trend_analysis which extracts structured trend intelligence — keywords (with stage and confidence), colors (with hex), silhouettes (rising/peaking/declining), price tier opportunity, and a market fit score. No simulated data.

3. DTC Demand Forecast

Ask your AI agent:

Forecast demand for our sneakers category for the next 3 months in the US market. We have 45 days of stock cover and our campaigns are running at 3.5x ROAS.

What happens: dtc_forecast_analysis computes a baseline demand for sneakers in summer, applies five multipliers (trend, media efficiency, retention, inventory, seasonality), and returns a forecast score with a ±20% confidence interval, driver contributions (each explained), risk flags, and three scenarios (base/upside/downside).

4. CRM Segment Enrichment

Ask your AI agent:

Enrich our "VIP Female 25-35" segment (5,000 customers, prefers dresses and bags) with current Summer 2026 trends so we can target them.

What happens: customer_trend_enrichment maps trending keywords, colors, and silhouettes onto the segment, produces audience clusters with propensity scores, and generates a CRM-ready campaign message.

5. Full Competitive Intelligence Workflow

Ask your AI agent:

I'm launching a sneaker brand. Analyze the current sneaker market trends, forecast demand, audit our first product page for SEO, and generate campaign creative.

What happens: Four tools fire in sequence — fashion_trend_analysis maps the market, dtc_forecast_analysis forecasts demand, product_seo_audit checks the launch page, and campaign_theme_recommendation generates platform-specific creative. Combined output gives market positioning + demand forecast + page fixes + campaign briefs.

Architecture

The server is organized into 6 layers that separate data acquisition, domain logic, fashion intelligence, and forecasting:

┌─────────────────────────────────────────────────────────┐
│                    AI Agent                              │
│  (Claude Code, Cursor, Codex, Gemini CLI, opencode)     │
└──────────────────────┬──────────────────────────────────┘
                       │
                       │  MCP stdio (JSON-RPC)
                       │  ListTools / CallTool
                       ▼
┌─────────────────────────────────────────────────────────┐
│                fashion-mcp-server (6-layer)              │
│                                                         │
│  ┌───────────────┐ ┌────────────────────────────────┐  │
│  │  Server Layer  │ │       Domain Layer              │  │
│  │  index.ts      │ │  ├── schemas/ (16 Zod schemas) │  │
│  │  mcp.ts        │ │  ├── entities/ (canonical)     │  │
│  │  registry.ts   │ │  ├── normalization/            │  │
│  │  errors.ts     │ │  │   ├── taxonomy/             │  │
│  │  (7 classes)   │ │  │   ├── resolver.ts           │  │
│  └───────┬───────┘ │  │   └── trends.ts              │  │
│          │         │  ├── scoring/ (SEO)             │  │
│          │         │  └── forecasting/               │  │
│          │         │      ├── engine.ts              │  │
│          │         │      ├── baseline.ts            │  │
│          │         │      ├── multipliers.ts         │  │
│          │         │      ├── scenarios.ts           │  │
│          │         │      └── backtest.ts            │  │
│          ▼         └────────────────────────────────┘  │
│  ┌──────────────────────────────────────────────────┐  │
│  │                Services Layer                     │  │
│  │  trend-intelligence, seo-audit, demand-forecast   │  │
│  │  feature-store                                    │  │
│  └──────────────┬───────────────────────────────────┘  │
│                 │                                      │
│     ┌───────────┴───────────┐                          │
│     ▼                       ▼                          │
│  ┌─────────────────┐  ┌────────────────────────────┐  │
│  │  Provider Layer  │  │    Storage Layer (SQLite)  │  │
│  │  Shopify (6 mth) │  │  snapshots, cache (TTL),   │  │
│  │  CRM (3: Klaviyo,│  │  features, forecast_actuals│  │
│  │   HubSpot, webhook)│  └────────────────────────────┘  │
│  │  Meta Ads, Google│                                │
│  │  Ads, GA4, GSC   │  ┌────────────────────────────┐  │
│  └─────────────────┘  │     Utils Layer             │  │
│                       │  text, dates, validation,    │  │
│                       │  pii-filter, write-back,     │  │
│                       │  env-check, logging          │  │
│                       └────────────────────────────┘  │
└─────────────────────────────────────────────────────────┘

Forecast engine

The forecast engine is a weighted-rule model that is fully explainable:

forecast_score = baseline_demand
               × trend_multiplier
               × media_efficiency_multiplier
               × retention_multiplier
               × inventory_multiplier
               × seasonality_multiplier

• Baseline: 9 categories × 4 seasons with market adjustment

• Multipliers: each returns a value and a human-readable explanation

• Confidence interval: ±20% around the forecast score

• Scenarios: base, upside (+20%), downside (-20%) with explicit adjustments

• Driver contributions: each driver reports its contribution % and explanation

• Backtesting: MAPE, WAPE, directional accuracy, bias, interval coverage — stored in forecast_actuals table

Error taxonomy

7 error classes, all extending McpError with structured metadata:

Privacy & safety

• PII filter: stripPii() redacts emails, phone numbers, credit cards on every write-back

• Aggregated-only forecasts: forecasts operate on segments, never personal profiles — isAggregatedOnly() guard

• Write-back opt-in: default dry_run: true; must explicitly set allow_writeback: true + destination to write

• Non-blocking env checks: providers are optional; missing credentials degrade gracefully

Skill Pack

This repo includes 16 markdown playbooks in fashion-mcp-skills/skills/ that orchestrate MCP servers into fashion-specific workflows. Skills use tool-agnostic ~~category placeholders so they work with any MCP server in that category — swap vendors without touching the playbook.

See fashion-mcp-skills/CONNECTORS.md for the full category→placeholder mapping.

Install skills

# Claude Code
cp -r fashion-mcp-skills/skills/* ~/.claude/skills/

# Cursor
cp -r fashion-mcp-skills/skills/* ~/.cursor/skills/

# Codex
cp -r fashion-mcp-skills/skills/* "${CODEX_HOME:-$HOME/.codex}/skills/"

Configuration

This server itself needs no API keys to start — 5 of 6 tools (product_seo_audit, dtc_forecast_analysis, category_demand_outlook, customer_trend_enrichment, campaign_theme_recommendation) work with data you pass directly. The only prerequisite is TAVILY_API_KEY, which belongs to the separate Tavily MCP server that feeds search data to fashion_trend_analysis. Provider integrations (Shopify, Klaviyo, Meta Ads, etc.) are optional — set their env vars to enable them. Missing credentials degrade gracefully (non-blocking).

A ready-to-use MCP config template is at .mcp.json.example.

Development

npm run dev          # Dev mode with hot reload
npm run typecheck    # Type checking
npm run build        # Production build
npm run start        # Run the server
npm test             # Run unit + e2e tests (141 tests)
npm run test:watch   # Watch mode

Testing

The project includes 141 tests across 13 test files:

Add a new tool

1. Create src/tools/<name>.ts

2. Define Zod input schema

3. Implement execute<Name> function

4. Export tool object with name, description, inputSchema, outputSchema, handler

5. Register in src/server/registry.ts

See docs/ARCHITECTURE.md for details.

Project Structure

src/                           # MCP server (Node/TypeScript)
├── index.ts                   # Server entry point
├── server/                    # Server layer
│   ├── mcp.ts                 # MCP bootstrap (ListTools + CallTool)
│   ├── registry.ts            # Tool registry (6 tools)
│   └── errors.ts              # Error taxonomy (7 classes)
├── domain/                    # Domain layer
│   ├── schemas/               # 16 Zod schemas (canonical)
│   ├── entities/              # Core entities
│   ├── normalization/         # Taxonomy + entity resolution
│   │   ├── taxonomy/          # dictionary, synonyms, classifier
│   │   ├── resolver.ts        # Entity dedup
│   │   ├── trends.ts          # Keyword/color/silhouette extraction
│   │   └── tavily.ts          # Content collection
│   ├── scoring/               # SEO scoring (15 audit functions)
│   ├── forecasting/           # Forecast engine + backtesting
│   │   ├── engine.ts          # computeForecast
│   │   ├── baseline.ts        # 9 categories × 4 seasons
│   │   ├── multipliers.ts     # 5 multipliers
│   │   ├── scenarios.ts       # base/upside/downside
│   │   └── backtest.ts        # MAPE, WAPE, directional accuracy
│   └── recommendations/       # Team actions generator
├── services/                  # Service layer
│   ├── trend-intelligence-service.ts
│   ├── seo-audit-service.ts
│   ├── demand-forecast-service.ts
│   └── feature-store-service.ts
├── providers/                 # Provider layer (normalizers)
│   ├── shopify/               # 6 methods
│   ├── crm/                   # Klaviyo, HubSpot, webhook
│   ├── meta-ads/
│   ├── google-ads/
│   ├── ga4/
│   └── search-console/
├── storage/                   # SQLite storage (better-sqlite3, WAL)
├── utils/                     # Utilities
│   ├── text.ts, dates.ts, validation.ts, logging.ts
│   ├── pii-filter.ts          # PII redaction
│   ├── write-back.ts          # Write-back guard
│   └── env-check.ts           # Non-blocking env checks
├── tools/                     # 6 tool implementations
├── types/fashion.ts           # Shared types
└── __tests__/                 # Unit + e2e tests (141)

fashion-mcp-skills/            # Skill pack (16 playbooks)
├── skills/                    # Playbook .md files
├── CONNECTORS.md              # Category→placeholder mapping
├── README.md
└── CLAUDE.md

docs/                          # Project docs
├── ROADMAP.md                 # 8-sprint roadmap
├── PAIN-MATRIX.md             # Pain analysis
├── ARCHITECTURE.md            # Architecture details
├── MCP-INTEGRATION-GUIDE.md   # External MCP integration
└── MARKETPLACE_DEPLOYMENT.md  # Publishing guide

Roadmap status

All 8 sprints from docs/ROADMAP.md are complete:

Marketplace

Published on:

• Smithery — install with one click

• Glama — MCP server discovery

• Pulse — MCP directory

See docs/MARKETPLACE_DEPLOYMENT.md for deployment instructions.

Resources

• MCP Protocol — Model Context Protocol specification

• MCP Servers Directory — Community MCP server catalog

• fashion-mcp-skills — Open-source skill pack for fashion retail

• MCP Integration Guide — How to connect external MCP servers

• Roadmap — 8-sprint development roadmap