amazon-sorftime-research-mcp-skill

# Amazon Sorftime Research MCP Skill > Skill by [ara.so](https://ara.so) — MCP Skills collection. This skill enables AI agents to perform comprehensive Amazon product research, competitor analysis, category selection, keyword research, and review analysis using the Sorftime MCP service. It provides seven core skills for cross-border e-commerce decision-making: listing analysis, category selection, keyword research, review analysis, product research, Sif research, and Xiyou insight. ## Overview The project integrates three MCP services (Sorftime, Sif, Xiyou) and provides Python-based analysis tools for: - **Single Listing Analysis**: Deep-dive into competitor products with keyword, review, and trend analysis - **Category Selection**: Market analysis of Top 100 products with five-dimension scoring - **Keyword Research**: 8-dimension intelligent classification of 1500+ keywords with ad strategy guidance - **Review Analysis**: 6-dimension pain point analysis with service risk warnings - **Product Research**: LLM-driven deep research workflow from data collection to decision - **Sif Research**: Market validation, competitor growth paths, keyword layout, and traffic diagnostics - **Xiyou Insight**: 7 scenario workflows for ad monitoring, traffic gap, competitor analysis, new product launch, ad budget transparency, and keyword database building ## Installation ### Prerequisites - Claude Code CLI or similar AI coding agent - Python 3.8+ - Bash shell environment - Sorftime API Key from [sorftime.com/zh-cn/mcp](https://sorftime.com/zh-cn/mcp) ### Setup MCP Configuration Create or update `.mcp.json` in your project root: ```json { "mcpServers": { "sorftime": { "type": "streamableHttp", "url": "https://mcp.sorftime.com?key=${SORFTIME_API_KEY}", "name": "Sorftime MCP" }, "sif": { "type": "streamableHttp", "url": "https://mcp.sif.com?key=${SIF_API_KEY}", "name": "Sif MCP" }, "xiyou": { "type": "streamableHttp", "url": "https://mcp.xiyou.com?key=${XIYOU_API_KEY}", "name": "Xiyou MCP" } } } ``` Set environment variables: ```bash export SORFTIME_API_KEY="your_sorftime_api_key" export SIF_API_KEY="your_sif_api_key" export XIYOU_API_KEY="your_xiyou_api_key" ``` ### Install Python Dependencies ```bash pip install -r requirements.txt ``` ## Core Skills and Commands ### 1. Listing Analysis (`amazon-analyse`) Analyze a single ASIN with comprehensive data including product details, reviews, keywords, and trends. ```bash # Analyze US marketplace listing /amazon-analyse B07PWTJ4H1 US # Analyze German marketplace listing /amazon-analyse B08N5WRWNW DE ``` **Python Implementation Pattern**: ```python import json import requests from datetime import datetime def analyze_listing(asin: str, site: str, mcp_url: str): """ Comprehensive listing analysis using Sorftime MCP """ # 1. Get product details product_detail = requests.post( mcp_url, json={ "method": "product_detail", "params": {"asin": asin, "site": site} } ).json() # 2. Get traffic keywords (top 100) traffic_keywords = requests.post( mcp_url, json={ "method": "product_traffic_terms", "params": {"asin": asin, "site": site, "limit": 100} } ).json() # 3. Get product reviews (last 100) reviews = requests.post( mcp_url, json={ "method": "product_reviews", "params": {"asin": asin, "site": site, "limit": 100} } ).json() # 4. Get product trends (90 days) trends = requests.post( mcp_url, json={ "method": "product_trend", "params": { "asin": asin, "site": site, "days": 90 } } ).json() # 5. Get competitor keyword layout competitor_keywords = requests.post( mcp_url, json={ "method": "competitor_product_keywords", "params": {"asin": asin, "site": site} } ).json() # Generate report report_data = { "asin": asin, "site": site, "product": product_detail, "keywords": traffic_keywords, "reviews": reviews, "trends": trends, "competitor_keywords": competitor_keywords, "analysis_date": datetime.now().isoformat() } # Save to reports directory report_path = f"reports/analysis_{asin}_{site}_{datetime.now().strftime('%Y%m%d')}.md" with open(report_path, 'w') as f: f.write(generate_markdown_report(report_data)) return report_data ``` **Output**: `reports/analysis_{ASIN}_{SITE}_{DATE}.md` ### 2. Category Selection (`category-selection`) Analyze category market with Top 100 products and five-dimension scoring model. ```bash # Analyze US Sofas & Couches category /category-selection "Sofas & Couches" US # Analyze specific number of products /category-selection "Wireless Earbuds" US --limit 20 ``` **Python Implementation Pattern**: ```python def analyze_category(category_name: str, site: str, limit: int = 100, mcp_url: str): """ Category selection analysis with five-dimension scoring """ # 1. Search for category nodeId category_search = requests.post( mcp_url, json={ "method": "category_name_search", "params": {"query": category_name, "site": site} } ).json() node_id = category_search[0]['nodeId'] # 2. Get category report (Top products) category_report = requests.post( mcp_url, json={ "method": "category_report", "params": { "nodeId": node_id, "site": site, "limit": limit } } ).json() # 3. Get category trends category_trends = requests.post( mcp_url, json={ "method": "category_trend", "params": {"nodeId": node_id, "site": site} } ).json() # 4. Calculate five-dimension scores scores = calculate_five_dimension_scores(category_report, category_trends) # 5. Generate multi-format reports report_dir = f"category-reports/{category_name}_{site}_{datetime.now().strftime('%Y%m%d')}" os.makedirs(report_dir, exist_ok=True) # Save Markdown report with open(f"{report_dir}/report.md", 'w') as f: f.write(generate_category_markdown(category_report, scores)) # Save Excel with charts generate_excel_report(f"{report_dir}/category_report.xlsx", category_report, scores) # Save HTML dashboard generate_html_dashboard(f"{report_dir}/dashboard.html", category_report, scores) return scores def calculate_five_dimension_scores(report_data, trend_data): """ Five-dimension scoring model (100 points total) """ return { "market_scale": calculate_market_scale_score(report_data), # 30 points "growth_potential": calculate_growth_score(trend_data), # 20 points "competition_level": calculate_competition_score(report_data), # 20 points "entry_barrier": calculate_barrier_score(report_data), # 15 points "profit_margin": calculate_profit_score(report_data) # 15 points } ``` **Five-Dimension Scoring Model**: | Dimension | Points | Criteria | |-----------|--------|----------| | Market Scale | 30 | Total sales volume, search volume, top seller performance | | Growth Potential | 20 | YoY growth rate, trend momentum, seasonality | | Competition Level | 20 | Number of sellers, review count distribution, brand concentration | | Entry Barrier | 15 | Average review count, established brand presence, capital requirements | | Profit Margin | 15 | Price range, cost structure, margin opportunity | **Output**: - `category-reports/{CATEGORY}_{SITE}_{DATE}/report.md` - `category-reports/{CATEGORY}_{SITE}_{DATE}/dashboard.html` - `category-reports/{CATEGORY}_{SITE}_{DATE}/category_report.xlsx` ### 3. Keyword Research (`keyword-research`) Deep keyword research with 8-dimension intelligent classification for 1500+ keywords. ```bash # Research keywords for an ASIN /keyword-research B0D9ZTW7PS US ``` **Python Implementation Pattern**: ```python def research_keywords(asin: str, site: str, mcp_url: str): """ 8-dimension keyword classification with ad strategy guidance """ # 1. Get traffic keywords traffic_keywords = requests.post( mcp_url, json={ "method": "product_traffic_terms", "params": {"asin": asin, "site": site, "limit": 100} } ).json() # 2. Expand related keywords for each traffic term all_keywords = [] for kw in traffic_keywords[:10]: # Top 10 keywords related = requests.post( mcp_url, json={ "method": "keyword_related_words", "params": {"keyword": kw['keyword'], "site": site} } ).json() all_keywords.extend(related) # 3. Get keyword details (search volume, CPC) for kw in all_keywords: detail = requests.post( mcp_url, json={ "method": "keyword_detail", "params": {"keyword": kw['keyword'], "site": site} } ).json() kw.update(detail) # 4. Classify keywords into 8 dimensions classified = classify_keywords_8_dimensions(all_keywords) # 5. Generate reports report_dir = f"keyword-reports/{asin}_{site}_{datetime.now().strftime('%Y%m%d')}" os.makedirs(report_dir, exist_ok=True) # Save CSV with all keywords save_keywords_csv(f"{report_dir}/keywords.csv", classified) # Save negative keywords list with open(f"{report_dir}/negative_words.txt", 'w') as f: f.write('\n'.join([kw['keyword'] for kw in classified['NEGATIVE']])) # Save category-specific CSVs for category, keywords in classified.items(): save_keywords_csv(f"{report_dir}/keywords_{category.lower()}.csv", keywords) # Generate dashboard generate_keyword_dashboard(f"{report_dir}/dashboard.html", classified) return classified def classify_keywords_8_dimensions(keywords: list) -> dict: """ 8-dimension intelligent classification """ categories = { "NEGATIVE": [], # Negative/sensitive words "BRAND": [], # Brand names "MATERIAL": [], # Material descriptors "SCENARIO": [], # Use case/scene words "ATTRIBUTE": [], # Attribute modifiers "FUNCTION": [], # Functional words "CORE": [], # Core product words "OTHER": [] # Uncategorized } for kw in keywords: category = classify_single_keyword(kw) categories[category].append(kw) return categories ``` **8-Dimension Classification**: | Dimension | Use Case | Ad Strategy | |-----------|----------|-------------| | NEGATIVE | Irrelevant/sensitive terms | Direct negation in campaigns | | BRAND | Competitor brand names | Competitor targeting or negation | | MATERIAL | Material descriptors (e.g., "stainless steel") | Exact match campaigns | | SCENARIO | Use case keywords (e.g., "outdoor camping") | Scene-based ad groups | | ATTRIBUTE | Attribute modifiers (e.g., "waterproof") | Long-tail exact match | | FUNCTION | Functional keywords (e.g., "fast charging") | Broad match for discovery |