npx -y @launchfast/mcp
# That's it. No git clone, no npm install, just works. ✨

// Dual caching strategy for 3x performance
Layer 1: Keyword → ASIN mapping (24h TTL)
Layer 2: Master product data per ASIN
Result: 2-5s cached vs 8-15s fresh

// Parallel processing with Promise.all()
const results = await Promise.all(
  asins.map(asin => fetchKeywordData(asin))
)

graph TB
    A[Claude Desktop] -->|JSON-RPC stdio| B[MCP Server]
    B -->|Tool Selection| C{Tool Handlers}
    C --> D[Market Research]
    C --> E[Keyword Intelligence]
    C --> F[Supplier Search]
    D -->|HTTPS| G[LaunchFast API]
    E -->|HTTPS| G
    F -->|HTTPS| G
    G -->|Auth & Rate Limiting| H[Data Services]
    H --> I[Amazon API]
    H --> J[Alibaba API]
    H --> K[Caching Layer]
    K -->|Optimized Response| B
    B -->|Formatted Data| A

User: "I want to launch bluetooth speakers on Amazon. Full analysis."

Claude executes:
1. Market research → Grade A7, $2.5M monthly revenue
2. Keyword analysis → 150+ keywords, 20 opportunities identified
3. Supplier search → 8 Gold Suppliers, MOQ 50-200, $12-45/unit
4. Profit calculation → $80-100/unit margin @ $149 price point
5. Launch strategy → Keywords, supplier, pricing, sales targets

{
  "mcpServers": {
    "launchfast": {
      "command": "npx",
      "args": ["-y", "@launchfast/mcp"],
      "env": {
        "LAUNCHFAST_API_URL": "https://launchfastlegacyx.com",
        "LAUNCHFAST_API_KEY": "lf_your_api_key_here"
      }
    }
  }
}

Research the Amazon market for "wireless chargers"

# Clone repository
git clone https://github.com/BlockchainHB/launchfastmcp.git
cd launchfastmcp

# Install dependencies
npm install

# Create .env file
cp .env.example .env
# Edit .env with your API credentials

# Build
npm run build

# Run locally (stdio mode)
npm run dev

# Run SSE server (web mode)
npm run dev:server

launchfastmcp/
├── src/
│   ├── index.ts                 # MCP server (stdio)
│   ├── server-sse.ts            # MCP server (SSE/HTTP)
│   ├── client/
│   │   └── launchfast-client.ts # API client with retry
│   ├── tools/
│   │   ├── market-research.ts   # Tool 1 handler
│   │   ├── asin-keywords.ts     # Tool 2 handler
│   │   └── alibaba-suppliers.ts # Tool 3 handler
│   ├── types/
│   │   └── launchfast.ts        # Type definitions
│   └── utils/
│       ├── logger.ts            # Structured logging
│       └── formatter.ts         # Response formatters
├── build/                       # Compiled output
├── .env.example                 # Environment template
├── package.json                 # npm metadata
├── tsconfig.json                # TypeScript config
└── README.md                    # This file

npm run build       # Compile TypeScript → JavaScript
npm run dev         # Run MCP server (stdio mode)
npm run dev:server  # Run SSE server (web clients)
npm run inspect     # Debug mode with source maps

async function fetchWithRetry(url: string, options: RequestInit, maxRetries = 3) {
  for (let attempt = 1; attempt <= maxRetries; attempt++) {
    try {
      const response = await fetch(url, options)

      // Don't retry 4xx errors (client errors)
      if (response.status >= 400 && response.status < 500) {
        return response
      }

      if (response.ok) return response

      // Retry 5xx errors with exponential backoff
      const backoff = Math.pow(2, attempt - 1) * 1000 // 1s, 2s, 4s
      await new Promise(resolve => setTimeout(resolve, backoff))
    } catch (err) {
      if (attempt === maxRetries) throw err
    }
  }
}

// Multiple fallback field mappings
const name = data.companyName || data.name || data.supplierName || 'Unknown'

// Null-safe number parsing
const moq = parseInt(data.moq?.toString() || '0') || 0

// Array safety
const items = Array.isArray(data.items) ? data.items : []

// Zod schemas for runtime validation
export const MarketResearchSchema = z.object({
  keyword: z.string().min(1),
  marketplace: z.string().default('com'),
  limit: z.number().int().min(1).max(100).default(50),
  useCache: z.boolean().default(true),
  filters: z.object({
    minPrice: z.number().optional(),
    maxPrice: z.number().optional(),
    minRating: z.number().min(0).max(5).optional()
  }).optional()
})

// Type inference
type MarketResearchRequest = z.infer<typeof MarketResearchSchema>

// Layer 1: Keyword → ASIN mapping (24h cache)
// Avoids expensive Amazon search API calls

// Layer 2: Master product data per ASIN
// Reuses product details across queries

// Result: 3x performance improvement