DEV Community: Tomi431

Automating Weekly Product Research With Claude and MCP

Tomi431 — Tue, 28 Jul 2026 08:01:41 +0000

Automating Weekly Product Research With Claude and MCP

Every Monday you open 4 tools, run the same queries, compile the same spreadsheet. You have been doing this for years. What if your AI did it for you in 30 seconds?

That is the promise of connecting Claude to live marketplace data through MCP -- the Model Context Protocol. Instead of logging into multiple dashboards, exporting CSV files, and stitching together a market picture by hand, you ask Claude one question and get a structured answer backed by real-time data. No switching tabs. No copy-paste. No pivot tables at 8 AM.

This article walks through how it works, what you can build with it, and how to set it up in under five minutes using the open-source sorftime-seller-agent MCP server.

The Weekly Research Routine, Deconstructed

Ask any marketplace seller what Monday morning looks like and the pattern is nearly identical across categories, revenue levels, and platforms. The player changes -- Amazon, Walmart, TikTok Shop, Shopee -- but the choreography does not.

Typical weekly research checklist:

Open the keyword tracker. Check which search terms shifted rank, which ones gained volume, which ones lost traction.
Open the competitor monitor. Scan for price changes, new listings, inventory signals, review velocity shifts.
Open the category dashboard. Look for new entrants, BSR movement, seasonal trend lines.
Open the profit calculator. Update cost inputs, check margin compression, flag SKUs that crossed below threshold.
Combine everything into a spreadsheet. Color-code the rows. Write a summary for the team.

Each step is 5 to 15 minutes of clicking through filters, date ranges, and export buttons. The cognitive load is not the analysis -- the analysis takes 30 seconds once the data is in one place. The load is the assembly. Assembling data from fragmented tools is where the hours disappear.

What Happens When MCP Replaces the Assembly

MCP lets Claude talk directly to external data sources as if they were built-in functions. Instead of you reading a dashboard and telling Claude what you saw, Claude reads the data itself and answers your question.

Here is a concrete example. You type this prompt into Claude after connecting sorftime-seller-agent:

"Check my tracked ASINs on Amazon US. Which competitors dropped price by more than 5 percent this week? Which keywords moved more than 10 positions? Flag any product with margin below 15 percent after fee changes. Output a table sorted by urgency."

Claude calls the relevant MCP tools -- fetching product details, keyword rankings, fee estimates -- combines the results, and returns a formatted table. Total time: roughly 30 seconds. The same analysis done manually: 45 minutes minimum, spread across three browser tabs and a spreadsheet.

The difference is not speed alone. It is that the bottleneck moves from data collection to decision-making. You stop being a human ETL pipeline and start being a strategist again.

What sorftime-seller-agent Provides

sorftime-seller-agent is an open-source MCP server that exposes marketplace intelligence as tools Claude can call. It covers over 130 endpoints across Amazon, Walmart, TikTok Shop, Shopee, Temu, and 1688.

Here is what Claude can do once the server is connected:

Read real-time product data: price, BSR, ratings, review count, inventory signals, buy box status.
Track keyword rankings across time periods and detect movement patterns.
Pull category-level data: bestseller lists, new releases, Movers and Shakers.
Calculate profit estimates with configurable cost inputs (COGS, FBA fees, referral fees, shipping).
Monitor competitor catalogs for new ASIN launches, price changes, and review velocity shifts.
Cross-reference data across platforms in a single query.

Each capability is a discrete tool in the MCP server. Claude decides which tools to call based on your question. You do not need to know the endpoint names or parameter formats -- Claude handles that automatically.

Setting It Up

The setup is three steps and takes under five minutes. You need Python 3.10 or later and a Claude client that supports MCP (Claude Desktop, Claude Code, or any MCP-compatible client).

Step 1: Clone and Install

git clone https://github.com/DannylydST/sorftime-seller-agent
cd sorftime-seller-agent
python3 scripts/install.py

The install script sets up a Python virtual environment, installs dependencies, and generates a starter configuration file.

Step 2: Configure Your MCP Client

Add the server to your Claude client's MCP configuration. For Claude Desktop, edit claude_desktop_config.json:

{
  "mcpServers": {
    "sorftime-seller-agent": {
      "command": "python3",
      "args": ["-m", "sorftime_seller_agent"],
      "env": {
        "SORFTIME_API_KEY": "your-api-key-here"
      }
    }
  }
}

For Claude Code, add it to .claude/mcp.json in your project or home directory with the same structure.

Step 3: Get an API Key

Sign up at open-intl.sorftime.com to get a free API key. The free tier includes enough quota to run weekly research workflows on a standard product portfolio.

Restart your Claude client. You should see a hammer icon or tool indicator confirming the MCP server is connected. Ask Claude: "List the tools you have access to." If sorftime-seller-agent tools appear, you are ready.

A Real Monday Morning Prompt

Once connected, here is a prompt you can use as a starting template. It covers the four core areas of a weekly review in a single query.

"Run my weekly product health check. For all ASINs I am tracking:

Compare current BSR and price against last week. Flag changes over 10 percent.

Pull keyword rankings for my top 5 target terms per ASIN. Note any position shifts.

Check for new competitors that entered the top 20 BSR in each ASIN's primary category.

Recalculate profit margins using current FBA fee estimates and my standard COGS. Highlight anything below 18 percent.

Format the output as a markdown table with one row per ASIN and a one-line verdict for each."

Claude executes this by calling the relevant tools in sequence, waiting for each result before making the next call, then synthesizing everything into a single structured table.

The first time you run it, review the output and refine the prompt -- add your specific margin thresholds, your competitor watchlist, the keywords that matter to your category. By the third week, the prompt is dialed in and Monday morning research takes the time it takes to type "run my weekly product health check."

Why This Architecture Works

There is a deeper reason this approach is gaining traction among marketplace sellers. Traditional SaaS dashboards are designed for human data consumption -- charts, tables, filters, export buttons. They optimize for a person looking at a screen and making decisions click by click.

MCP flips the model. Data flows directly into the reasoning engine. Claude does not need a chart. It needs structured numbers, and it is better at spotting patterns across multiple data dimensions than a human scanning a dashboard.

This also means your research scales without adding headcount. Tracking 10 ASINs or 100 ASINs is the same prompt. Claude handles the fan-out, calling tools for each ASIN and aggregating results. What changes is execution time, not your effort.

What This Does Not Do

A few honest boundaries. The MCP server provides data access and tool definitions. It does not make business decisions for you. It will not tell you which product to launch. It will not guarantee a keyword ranks or a margin holds. Market conditions shift, fees change, and data always has a freshness window.

The value is in removing the repetitive assembly work so you can spend your attention on the decisions that require judgment. Think of it as moving from "person who collects data" to "person who interprets data."

Try It Yourself

git clone https://github.com/DannylydST/sorftime-seller-agent && cd sorftime-seller-agent && python3 scripts/install.py

Free API keys are available at open-intl.sorftime.com. The source code is open -- read it, fork it, extend the tools to match your workflow. If you build something useful, open a pull request.

One prompt. Thirty seconds. No more Monday spreadsheet assembly.

No Terminal? No Problem — How Non-Technical Amazon Sellers Can Use MCP Today

Tomi431 — Mon, 27 Jul 2026 11:18:42 +0000

You hear "command line" and your eyes glaze over. You're a seller, not a developer. But here's the thing: MCP isn't just for programmers anymore. In the time it takes to brew a cup of coffee, you can connect an AI assistant to live Amazon marketplace data — inventory levels, pricing trends, competitor moves — and have it answer your questions in plain English. No coding required. No technical background needed. Just copy, paste, and ask.

What is MCP, and Why Should a Seller Care

MCP stands for Model Context Protocol. It is an open standard that lets AI tools talk to external data sources. Think of it as a universal adapter. Your AI assistant on one side, real-time marketplace data on the other, and MCP is the cable that connects them.

Here is what that means in practice. Normally, to research a product on Amazon, a seller opens multiple browser tabs, copies numbers into a spreadsheet, compares prices manually, and repeats this ritual across twenty or thirty ASINs. That process might take an afternoon. With an MCP server connected to marketplace data, the same seller types a question like "Show me every product in the Home & Kitchen category with a BSR under 5,000 that is sold by fewer than three competitors" — and gets an answer in seconds.

The key word here is "connected." AI on its own knows nothing about your specific market. It has general knowledge, but it does not know what is happening on Amazon right now. MCP gives it access to that data. Suddenly the AI stops being a general-purpose chatbot and becomes a research assistant that understands your category.

The Terminal Looks Scary. It Isn't.

The biggest barrier for non-technical sellers is the command line. A black window with white text and a blinking cursor. It looks like something from a 1980s hacker movie, and for most people, the instinct is to close it immediately.

Here is the reality: you will use exactly four commands, and you will copy-paste every single one of them. You do not need to understand what they do. The instructions tell you what to type, and you copy it. That is the entire skill requirement.

The terminal works like this: you paste text, you press Enter, something happens. Then you paste the next line, press Enter, something else happens. It is closer to filling out a web form than it is to programming. If the instructions say "copy the line starting with git clone and press Enter," you select that line, you paste it into the terminal, and you press Enter. The computer handles everything else.

Still nervous. That is fine. Here is what happens if something goes wrong: nothing. The terminal prints an error message. You read the message, you search for it on Google, or you ask a technical friend. No data gets deleted. Your Amazon account stays untouched. The worst-case scenario is that a command does not work and you try again. There is no irreversible damage to worry about.

Step by Step: Get It Running in Under 10 Minutes

You need three things before starting: a computer running macOS, Windows, or Linux; a Claude Desktop or Claude Code account (free tier works); and an internet connection. That is it.

Open your terminal. On macOS, press Command-Space, type "Terminal," and press Enter. On Windows, press the Windows key, type "PowerShell," and press Enter. You will see a blank window with a prompt. Copy and paste the following commands one at a time, pressing Enter after each one.

Step 1: Install the MCP server.

git clone https://github.com/sorftime/sorftime-seller-agent.git
cd sorftime-seller-agent
npm install

The first line downloads the software. The second line moves you into the project folder. The third line installs any dependencies it needs. Each line takes a few seconds. If a line asks for confirmation, type y and press Enter.

Step 2: Configure your API key.

You need a Sorftime API key to access marketplace data. Go to open-intl.sorftime.com, create a free account, and copy your API key from the dashboard. Then run:

echo "SORFTIME_API_KEY=your-key-here" > .env

Replace your-key-here with the actual key you copied. This saves your key in a configuration file so the MCP server can use it. The key is stored on your computer only — no data leaves your machine without your asking.

Step 3: Connect it to your AI assistant.

For Claude Desktop users, open Settings, go to the Developer tab, click "Edit Config," and add this block to the file that opens:

{
  "mcpServers": {
    "sorftime-seller-agent": {
      "command": "node",
      "args": ["/path/to/sorftime-seller-agent/index.js"],
      "env": {
        "SORFTIME_API_KEY": "your-key-here"
      }
    }
  }
}

Replace /path/to/sorftime-seller-agent with the actual folder path where you cloned the project. Save the file and restart Claude Desktop. A small plug icon will appear in the chat input — that means the connection is live.

For Claude Code users, add the same configuration to your ~/.claude/mcp.json file and restart Claude Code.

What You Can Actually Do With It

Once the MCP server is connected, you ask questions in plain English directly in your AI chat window. Here are a few workflows that take seconds instead of hours.

Competitor reconnaissance. Type: "Find all sellers in my category who launched new products in the last 30 days. For each one, show me their price point, review count, and whether they are running coupons." The agent queries live Amazon data and returns a structured answer. You can spot competitive threats the day they appear, not weeks later when they are already ranking.

Pricing optimization. Type: "Track the Buy Box price for ASIN B0XXXXXXX over the last 14 days. Show me the high, low, and average. Flag any days where the price dropped by more than 10 percent." The agent pulls historical pricing data and highlights the patterns worth acting on.

Inventory gap detection. Type: "Show me every product in Patio, Lawn & Garden with a BSR under 2,000 that has stock levels below 50 units." This reveals which competitors are about to stock out — an opportunity to capture their traffic if you have inventory available.

Profitability screening. Type: "For these ten ASINs, calculate estimated net margin after FBA fees, referral fees, and estimated PPC cost at a 10 percent ACOS." The agent walks through each calculation and ranks the products by profitability.

Every answer is based on real data from Amazon, not on training data that is months out of date. The numbers you see reflect what is actually happening on the marketplace right now.

The Open-Source Difference

Most marketplace intelligence tools are closed platforms. The data lives on someone else's server, the algorithms are a black box, and the monthly subscription locks you in. sorftime-seller-agent is open source under the MIT license. The code is public on GitHub. Anyone can inspect how it works, suggest improvements, or modify it for their own needs. There is no vendor lock-in. If the service ever changes in a way that does not suit your business, you can fork the code and keep running your own version.

Being open source also means the community drives what gets built. Feature requests come from real sellers dealing with real problems. The roadmap is visible. Every update is documented in the changelog. This is not a product where someone in a boardroom decides what sellers need — it is shaped by the people who use it every day.

Next Steps

The commands above are everything you need to get started. Copy them one at a time, press Enter, and you will have an AI research assistant connected to live Amazon data in under ten minutes. From there, the best way to learn is to ask it questions about your own business. Start simple: ask about a single ASIN you know well. See how the data comes back. Then ask broader questions. The system gets more useful the more you use it.

Try it yourself:

git clone https://github.com/sorftime/sorftime-seller-agent.git

Get your API key at open-intl.sorftime.com. Documentation, example prompts, and community support are available at the same URL. Questions and feature requests are welcome on the GitHub repository.

Calculate Amazon Profit in Seconds -- Not Hours -- With Your AI Agent

Tomi431 — Mon, 27 Jul 2026 11:03:23 +0000

You found a product. Now you need to calculate FBA fees, shipping, referral fees, cost of goods, and break-even. You open a spreadsheet.

First, you look up the FBA fee schedule for the product's size tier. You check whether it falls into small standard, large standard, or oversize -- and which sub-tier within each. You dig up the referral fee percentage for the category. You pull a shipping rate from your freight forwarder's last email. You estimate packaging cost, inbound placement fees, and storage fees if the product is seasonal. You type each number into a cell, write a formula, and stare at the result.

Then you change the price by two dollars and do it again.

Then you wonder what happens if the landed cost goes up 12%. Then you check a different weight estimate. Then you realize you forgot the returns cost. You update the formula. It is now forty-five minutes later, and you have analyzed one product.

This workflow is universal among Amazon sellers. It is also slow, error-prone, and the single largest bottleneck between having an idea and acting on it.

What Makes Amazon Profit Math Complicated

Amazon profit calculation is not a single formula. It is a chain of interdependent estimates that change with product dimensions, category, fulfillment method, and season.

The minimum inputs for a reliable per-unit profit estimate include:

Referral fee: 8% to 45% depending on category, with per-item minimums that can dominate low-ASP products
FBA fulfillment fee: Determined by size tier, dimensional weight, and shipping weight -- a product that is one inch over a tier boundary can see fulfillment costs jump
Inbound shipping: Freight costs from supplier to FBA, allocated per unit
Storage fees: Monthly inventory storage, with sharply higher rates during Q4
Cost of goods: Landed cost including manufacturing, inspection, and import duties
Returns cost: Average return rate for the category, multiplied by the cost of processing a return (shipping, disposal, or restocking)
PPC allocation: If advertising is part of the launch, the per-unit ad cost affects true net margin

Getting these numbers right requires cross-referencing the FBA revenue calculator, a freight quote, a duty rate table, and your supplier invoice -- for every product, at every price point you are considering.

An AI Agent That Does the Arithmetic

The sorftime-seller-agent is an open-source MCP (Model Context Protocol) tool that connects any compatible AI agent to marketplace data and profit analysis. You install it once, and your AI agent gains the ability to call structured analysis functions -- including a profit calculator that pulls live fee data, not stale spreadsheet estimates.

Here is what asking for a profit analysis looks like. You are evaluating a kitchen gadget priced at $24.99:

I am evaluating a product on Amazon US. Calculate the unit economics:

- Selling price: $24.99
- Cost of goods (landed): $6.80
- Product weight: 0.8 lbs
- Dimensions: 9.4 x 6.2 x 2.1 inches
- Category: Kitchen & Dining
- Estimated monthly returns: 4%
- Inbound shipping per unit: $0.45
- Target monthly volume: 300 units

Give me per-unit breakdown: referral fee, FBA fee, storage estimate, net profit, and margin.
Then show breakeven volume at this price point and a sensitivity table at $22.99 and $27.99.

Your AI agent calls the relevant tools -- product_profit_calculator for FBA fee estimates based on the actual size tier, referral fee by category, and storage fee modeling -- and returns a structured breakdown in under 30 seconds.

Contrast this with the spreadsheet workflow. In the time it takes to manually calculate one product at one price, the AI agent can run a full sensitivity analysis across multiple price points, weight scenarios, and volume assumptions. The arithmetic is the same either way. The difference is who does the lookup, the formula-writing, and the re-checking.

Beyond the Single-Product Calculation

The real power of having profit analysis connected to an AI agent is that you can ask follow-up questions the way you would with an analyst on your team:

"Run the same numbers but assume I ship by sea instead of air -- how does margin change?"
"Compare this product's unit economics against the top 3 competing ASINs in the same category."
"What price band has the highest net margin when you factor in the FBA fee tier boundaries for this product's dimensions?"
"Calculate the monthly profit projection for 6 months, factoring in Q4 storage fee increases and a conservative 15% monthly sales ramp."

Each of these questions would require rebuilding a spreadsheet from scratch. With the MCP tools connected, each one is a sentence in a conversation.

Setting It Up

The install is one command:

git clone https://github.com/DannylydST/sorftime-seller-agent && cd sorftime-seller-agent && python3 scripts/install.py

The installer sets up a Python virtual environment, pulls dependencies, and configures your AI agent to discover the MCP tools automatically. You need a free Sorftime account at open-intl.sorftime.com for the API key. No credit card required.

Once installed, restart your AI agent and ask your first profit question. The tools are available to Claude Code, Codex CLI, Cursor, and any other MCP-compatible agent.

What It Does Not Do

The profit calculator provides estimates based on published FBA fee schedules, standard referral fee rates, and user-supplied inputs. It does not guarantee that your actual fees will match the estimate exactly -- dimensional tier assignments can change when Amazon measures your product at the fulfillment center, and storage fee surcharges depend on actual inventory turnover.

It does not predict sales volume, forecast demand, or tell you whether a product is a good investment. It does the arithmetic so you can focus on the judgment.

Profit analysis is probabilistic, not deterministic. The tool makes the probabilities visible faster than a spreadsheet can. What you do with them is your call.

Try it yourself.

git clone https://github.com/DannylydST/sorftime-seller-agent && cd sorftime-seller-agent && python3 scripts/install.py

Free API key at open-intl.sorftime.com. Then ask your AI agent: "Calculate the profit for a product in my category at my target price." The arithmetic is ready. The next question is yours.

Published: 2026-07-27 | Sorftime International Blog

Mine Amazon Reviews for Product Ideas — Automatically With AI

Tomi431 — Mon, 27 Jul 2026 10:47:15 +0000

Your competitors' negative reviews are a goldmine of product improvement ideas. But reading thousands of reviews manually is impossible. A single best-selling product on Amazon can accumulate 5,000 reviews, each one a data point about what customers actually want — and what they cannot stand about the current options. Multiply that across five or six competitors in a category, and the volume becomes unmanageable.

The information is all there. Buyers spell out exactly which features they wish existed, which materials keep failing, and which gaps in the market nobody has filled. The problem has never been a lack of signal. It has been that extracting signal from thousands of unstructured reviews requires automation.

The sorftime-seller-agent is an open-source MCP tool that gives any AI agent direct access to marketplace intelligence. One of its analysis frameworks — the Review Mining methodology — is designed specifically for this problem. Instead of skimming reviews and hoping to notice patterns, an AI agent can pull review data across competitor ASINs, rank pain points by severity, and surface the specific product improvements that would actually make a difference.

Beyond Word-Frequency Counters

Most review analysis tools do something simple: count how often each word appears and call the most frequent ones the biggest problems. If "battery" appears 200 times and "noise" appears 150 times, they report that battery life is the top issue.

This approach has a blind spot. People who mention "battery" may have given 4 stars — they think the battery life is slightly short but otherwise like the product. Meanwhile, 80% of the people who mention a less frequent term are leaving 1-star reviews and returning the item. A word-frequency counter would rank "battery" above a rarer but far more damaging issue.

The Review Mining methodology uses a Pain Point Severity Index instead:

Severity Index = Mention Frequency Score x Rating Negative-Correlation Coefficient

A term that appears infrequently but is almost always tied to 1-star reviews ranks higher than a frequently mentioned term spread across 4-star and 5-star reviews. The approach catches issues that simpler tools miss — a material defect mentioned only 15 times across a category, but every single mention is a 1-star return, is exactly the kind of signal a seller needs to act on.

How It Works in Practice

With the sorftime-seller-agent installed and configured, a seller can ask their AI agent:

Pull reviews for the top 5 competitors in portable blenders on Amazon US.
Identify the highest-severity pain points across all of them.
Tell me which problems are category-wide versus specific to one competitor.
For each top pain point, suggest a concrete product improvement.

The AI agent calls the relevant MCP tools — product_reviews to pull review data, product_detail to cross-check listing content — and runs the severity analysis. What comes back looks something like:

Leaking seal (Severity: 0.91) — Appears across 4 of 5 competitors. Every mention is 1 or 2 stars. All competitors use the same silicone gasket design. Improvement opportunity: redesigned dual-gasket sealing mechanism, or a locking lid mechanism similar to premium insulated bottles.
Motor burns out after 3-4 months (Severity: 0.87) — Mentioned in 12% of 1-star reviews, consistent across competitors. Suggests a category-wide motor durability ceiling at current price points. Improvement opportunity: slightly larger motor with thermal cutoff protection; the higher COGS may be justified by reduced return rate.
Hard to clean under blades (Severity: 0.72) — Category-wide complaint. No competitor's listing addresses this in A+ content or product copy. Improvement opportunity: removable blade assembly for dishwasher cleaning; this becomes a differentiation point until competitors catch up.

The third example is worth highlighting: a pain point that every competitor shares but no one has solved in their listing copy. That is a market positioning gap, not just a product gap. The first seller to address it — both in the product and in the listing — captures the buyer attention of everyone who has ever been frustrated by the problem.

Setting It Up

Installation is a single command.

git clone https://github.com/DannylydST/sorftime-seller-agent && cd sorftime-seller-agent && python3 scripts/install.py

The installer sets up a Python virtual environment, installs dependencies, and generates the MCP configuration. A free Sorftime MCP key — available at open-intl.sorftime.com — is required. No credit card is needed for trial access.

Once configured, the agent can call any of the 86 marketplace intelligence tools across six platforms. The review mining workflow specifically uses product_reviews for review data retrieval and product_detail for cross-referencing listing content against identified pain points.

What the Tool Does and Does Not Do

The methodology surfaces patterns that manual review reading would take days to find. But it has limitations worth understanding upfront:

Review data older than six months may describe problems that have already been fixed in newer production runs. Severity analysis should weight recent reviews more heavily.
Some pain points are physical constraints, not design flaws. A complaint that "these headphones are not small enough" does not mean there is a viable engineering solution — it may simply mean the user wants an in-ear monitor but bought over-ear headphones.
ASINs with fewer than 50 total reviews carry high sample bias. The analysis is still useful as a directional indicator, but should not be treated as statistically reliable.
Review manipulation on Amazon is a known issue. If a competitor has purchased a large volume of 5-star reviews, the Severity Index will underweight genuine negative signals because the overall rating distribution is distorted. Cross-check with total review count and velocity to identify suspicious patterns.

The tool identifies opportunities. It does not validate them. A pain point with a high Severity Index tells a seller where to investigate — it does not confirm that solving that pain point is profitable or manufacturable. That judgment remains, as it should, with the seller.

Why This Matters

Amazon is a competitive marketplace where product differentiation is increasingly difficult. If a seller makes the same product as everyone else, with the same features, the same materials, and the same weaknesses, the only lever left is price. Racing to the bottom on price is not a strategy — it is a slow exit.

Review mining changes the equation. Instead of guessing what features buyers want, a seller can extract those demands directly from the market's own feedback. Every negative review is a specification written by a paying customer. The question is whether anyone reads it.

Try It

The sorftime-seller-agent is open source under the MIT license. Clone the repository, install it, and ask your AI agent to analyze a category.

git clone https://github.com/DannylydST/sorftime-seller-agent && cd sorftime-seller-agent && python3 scripts/install.py

Then ask your AI:

Pull reviews for the top 5 competitors in [your category] on Amazon US.
Rank the pain points by severity. Show me which ones are category-wide.
For the top 3, suggest concrete product improvements.

Get a free MCP key at open-intl.sorftime.com. Works with any MCP-compatible AI agent, including Claude Code, Codex, Cursor, and OpenClaw.

References

[1] Sorftime Seller Agent GitHub Repository — https://github.com/DannylydST/sorftime-seller-agent
[2] Sorftime International MCP Portal — https://open-intl.sorftime.com
[3] Model Context Protocol Specification — https://modelcontextprotocol.io

Spot Seasonal Trends Before Your Competitors — Data-Driven Timing With MCP

Tomi431 — Mon, 27 Jul 2026 10:36:43 +0000

Every seasonal selling cycle presents the same two-sided dilemma. Order inventory too early and capital sits frozen in a warehouse for months, accruing storage fees while the calendar crawls toward peak demand. Order too late and the window closes before the shipment clears customs — competitors who timed it right capture the surge, and the seller is left holding stock that arrives just as demand collapses.

The difference between these two outcomes is rarely about luck. It is about visibility. Sellers who get seasonal timing right are not guessing better; they are watching the right data earlier, and they are watching it continuously, not in a single planning spreadsheet assembled in April and never revisited.

The Data That Predicts a Season

A seasonal trend does not announce itself with a calendar notification. It builds gradually across multiple signals, each of which is visible weeks or months before the sales curve turns upward.

Search volume for category-defining keywords begins rising before purchase volume follows. Competitor inventory levels for seasonal variants — holiday-themed packaging, summer-specific materials, gift-ready bundles — start shifting as experienced sellers position early. New listing velocity in a seasonal subcategory accelerates two to three months before peak, as sellers who spotted the trend early rush to claim shelf space. Price compression in previously stable ASINs signals that supply is expanding ahead of demand.

Each of these signals is individually subtle. A 5% week-over-week search volume increase is easy to dismiss as noise. A single new competitor entering a category is unremarkable. But when search volume is rising across five related keywords, three new sellers have entered in the past month, and average price has drifted down 8% from six months ago, the pattern is unambiguous. The season is coming, and the sellers who recognize the shift earliest capture the best positioning.

The challenge is not that this data is unavailable. It is that pulling it manually — logging into multiple dashboards, exporting separate reports for each signal, cross-referencing dates and metrics across different tools — takes hours per category per week. For a seller monitoring seasonal patterns across six categories, this becomes a full-time job that nobody has time to do.

What Changes With an MCP-Connected Agent

The Model Context Protocol (MCP) lets an AI agent connect directly to structured marketplace data sources. Instead of a human navigating dashboards and exporting reports, the agent retrieves data programmatically, compares it across time periods, and surfaces patterns that would take hours to assemble manually.

The sorftime-seller-agent is an open-source MCP server that gives any MCP-compatible agent access to marketplace intelligence — product data, keyword trends, category dynamics, and competitor metrics across major e-commerce platforms. Once configured, a single natural-language question can trigger a multi-signal seasonal analysis that runs in seconds.

Consider a seller preparing for the holiday gift season on Amazon US. The manual approach: open the keyword research tool, pull 12-month search trends for 15 gift-category keywords, export each to CSV, open the category analysis tool, pull listing velocity and average price for the target subcategory, export again, merge everything in a spreadsheet, and attempt to read the pattern across disconnected tables. Realistically, this happens once, maybe twice, before the season. It does not happen every week as conditions shift.

With an MCP-connected agent, the analysis becomes a query that runs on demand:

"Compare search volume trends for the top 10 gift-category keywords across Q3 and Q4 of last year versus this year. Identify which keywords are showing earlier acceleration this year. Cross-reference with new listing velocity in the corresponding subcategories. Flag any subcategory where new listings are entering faster than last year but average price has not yet started declining."

The agent calls the relevant endpoints — keyword trend, category overview, product listing — retrieves structured data from each, and returns a synthesized analysis. The round trip completes in seconds. The data is live, not a snapshot from whenever the CSV was last exported. The cross-referencing is programmatic, not a chain of VLOOKUPs that breaks when column headers shift.

Here is what configuring the agent looks like. Drop this into the MCP settings for Claude, Cursor, Codex, or any compatible client:

{
  "mcpServers": {
    "sorftime-seller-agent": {
      "command": "python3",
      "args": ["-m", "sorftime_seller_agent"],
      "env": {
        "SORFTIME_API_KEY": "your-api-key"
      }
    }
  }
}

Once connected, the agent can run seasonal scans like this:

 A seasonal readiness scan — run this weekly starting 12 weeks before peak
scan_prompt = """
For Amazon US, analyze the following seasonal readiness signals
across the Kitchen & Dining gift subcategories:

1. Keyword search volume: pull 90-day trends for the top 15 gift-adjacent
   keywords. Flag any keyword where the current week's volume exceeds the
   12-week trailing average by more than 20%.

2. New listing velocity: count new ASINs added to each subcategory in the
   past 30 days. Compare to the same period last year.

3. Price trend: compute average price across the top 50 listings for each
   subcategory. Flag any subcategory where price has declined more than
   5% over 60 days (supply expanding ahead of demand).

4. Review velocity on seasonal variants: identify listings with seasonal
   keywords in their titles that launched in the past 60 days. Flag any
   that have accumulated more than 30 reviews already (early entrants
   gaining traction).

Return a ranked watchlist of subcategories by seasonal acceleration
score, with supporting data for each signal.
"""

The output is not a data dump. It is a prioritized watchlist with specific subcategories ranked by how strongly seasonal patterns are materializing, backed by the underlying metrics. The seller reads the analysis, applies judgment about which categories match their sourcing capabilities and risk tolerance, and makes a decision. The agent handled the retrieval, comparison, and pattern detection. The human handled the decision.

From Annual Ritual to Weekly Discipline

The architecture shift matters beyond any single query. When seasonal analysis requires three hours of manual data work per category, it becomes an annual ritual — done once during planning season and then abandoned as daily operations consume all available attention. This means the seller operates on a seasonal forecast that might be four months old by the time orders need to be placed. Conditions that changed in week six do not surface until the post-season retrospective, when the lesson is learned but the window is gone.

When the same analysis runs as a prompt through an MCP-connected agent, it becomes a weekly discipline. The cost drops from three hours to thirty seconds. That changes the feasible frequency from once per season to once per week, or even daily as peak approaches. A price compression signal detected in week two of the build-up, rather than week eight, shifts the sourcing strategy before capital is committed. A search volume acceleration detected three weeks earlier than last year moves the entire timeline forward.

This is not about replacing judgment with automation. It is about giving judgment better data, more frequently, at lower cost. The seller still decides when to order, what to order, and how much. The difference is that those decisions are informed by current signals rather than a frozen snapshot.

Getting Started

sorftime-seller-agent is open-source and free to use. It connects to marketplace data across major global platforms and works with any MCP-compatible AI agent.

git clone https://github.com/DannylydST/sorftime-seller-agent && cd sorftime-seller-agent && python3 scripts/install.py

From Spreadsheets to MCP —Build a Seller Data Pipeline in 5 Minutes

Tomi431 — Mon, 27 Jul 2026 10:25:11 +0000

Every Monday you export CSVs from 3 tools, merge them in Excel, and spend 2 hours making sense of it. By Tuesday morning the data is already stale, and half the columns you pulled turn out to be irrelevant. The following week, the same cycle repeats.

This ritual costs more than time. Manual data pipelines introduce errors at every step — copy-paste mistakes, broken formulas, inconsistent date ranges. Worse, they create latency between when data becomes available and when decisions get made. In a marketplace where pricing, rankings, and inventory shift by the hour, a 48-hour gap between data pull and analysis is a structural disadvantage.

The Model Context Protocol (MCP) changes this by letting AI agents connect directly to data sources. Instead of exporting data and feeding it to an analysis tool, the analysis tool connects to the data at the source. A single natural-language question can pull live data from multiple endpoints, cross-reference it, and deliver a formatted answer — all without touching a spreadsheet.

What sorftime-seller-agent Does

sorftime-seller-agent is an open-source MCP server that gives any MCP-compatible AI agent — Claude, Cursor, Codex, and others — direct access to marketplace intelligence. It covers product research, keyword analysis, category trends, competitor tracking, and profit estimation across major e-commerce platforms. Once configured, the agent becomes a data analyst that reads live marketplace data on demand.

The setup takes a single configuration file and one install command. Drop the following into the MCP configuration for the agent of choice:

{
  "mcpServers": {
    "sorftime-seller-agent": {
      "command": "python3",
      "args": ["-m", "sorftime_seller_agent"],
      "env": {
        "SORFTIME_API_KEY": "your-api-key"
      }
    }
  }
}

For Claude, this goes into claude_desktop_config.json. For Cursor, .cursor/mcp.json. For Codex, the equivalent MCP settings file. Run the install script once, restart the agent, and marketplace data tools are available immediately.

From Query to Insight in Seconds

A concrete example makes the shift tangible. Consider a seller evaluating the competitive landscape for yoga mats on Amazon US — a category with thousands of listings, wide price dispersion, and frequent new entrants.

The manual approach: export a category report, filter by subcategory, pull individual ASIN data for the top listings, cross-reference review counts and estimated revenue, build a pricing table in Excel, and manually scan for patterns. Two to three hours, assuming no formula errors and no need to re-export when a filter was wrong.

With sorftime-seller-agent configured, the same research begins with a single sentence typed into the agent:

"Analyze the top 50 yoga mats on Amazon US. Show average price by material type, identify listings with under 100 reviews but strong revenue growth, and flag products that entered the category in the last 90 days with monthly revenue above $50,000."

Behind the scenes, the agent calls the relevant MCP tools — category listing, product detail, sales estimation — retrieves structured data from each endpoint, and synthesizes the answer. The round trip runs in seconds. The data is live. Cross-referencing happens programmatically, not through VLOOKUP. The output is a narrative summary with supporting tables, ready to inform a sourcing decision or discard a bad lead before hours are wasted.

Why the Architecture Matters

The difference between spreadsheets and MCP is architectural, not cosmetic.

A spreadsheet pipeline is pull-based: data must be exported, cleaned, transformed, and loaded before analysis can begin. Every step is a manual touchpoint. Every touchpoint is a potential error. When the data changes tomorrow, the whole process repeats from scratch.

An MCP pipeline is query-based: data lives at the source, and the agent retrieves exactly what is needed, when it is needed. No exports. No cleaning. No version conflicts between CSV files exported on different days with different filters. The question drives the data retrieval, not the other way around.

This eliminates several categories of failure at once: stale data, formula drift, silent filter mismatches, and the cognitive overhead of maintaining spreadsheet hygiene across dozens of weekly exports.

Beyond One-Off Research

The same MCP connection supports recurring workflows without additional integration work. A daily category snapshot becomes a scheduled prompt. Weekly competitor monitoring becomes a recurring query. An alert when a tracked product's rank drops below a threshold is a simple conditional check run through the same pipeline.

These are not separate integrations requiring new API keys, new dashboards, or new tools. They are different prompts sent through the same MCP connection, scheduled with the agent's built-in automation — Claude Code's loop command, a cron job wrapping a Cursor agent session, or any equivalent mechanism.

Who This Is For

sorftime-seller-agent is designed for marketplace sellers who already understand their business but waste too many hours on data logistics. It does not replace domain expertise — the seller still decides what to research, which metrics matter, and what action to take. The pipeline handles retrieval, cross-referencing, and formatting. The seller handles judgment.

The tool is open-source and free to use. The data coverage spans major global marketplaces, and the MCP interface means it works with whichever AI agent the seller already prefers.

Try it:

git clone https://github.com/DannylydST/sorftime-seller-agent && cd sorftime-seller-agent && python3 scripts/install.py

Free at open-intl.sorftime.com.