trading_skills gives Claude twenty-odd market tools and one opt-in order path

Two front ends, and the MCP path is the lighter one

There are two ways in, and they differ more than the documentation first suggests.

The full experience is Claude Code or Cursor with third-party skills enabled, run in the repository root:

git clone https://github.com/staskh/trading_skills.git
cd trading_skills
uv sync

Every skill then shows up as an interactive command you invoke by asking. This is the mode for the Python-literate audience the project names, because the source is sitting right there to extend.

The MCP server is the other route, aimed at Claude Desktop including its free tier, and it is described as a lightweight alternative that exposes 23 trading analysis tools directly without needing Claude Code. Install it from PyPI with pip install trading-skills, locate the trading-skills-mcp command, and register it in claude_desktop_config.json. There is also a no-install variant that runs straight from the repository:

{
  "mcpServers": {
    "trading-skills": {
      "command": "uvx",
      "args": ["--from", "git+https://github.com/staskh/trading_skills.git", "trading-skills-mcp"]
    }
  }
}

On Windows the same entry is wrapped in cmd with a /c argument, which is the standard way to launch a console script there.

One instruction in that section is worth repeating because it looks like a bug: after restarting Claude Desktop you may see an MCP error message, and the README says not to worry because it disappears once you try one of the examples.

Read-only by default, with exactly one path that writes

The portfolio features are split by what the TWS API connection is allowed to do, and the split is unusually explicit.

Nine skills are labelled read-only. They fetch positions, prices and Greeks and place no orders: ib-account, ib-portfolio, ib-option-chain, ib-find-short-roll, ib-collar, ib-pmcc-advisor, ib-portfolio-action-report, ib-create-consolidated-report, and ib-report-delta-adjusted-notional-exposure.

Exactly one skill is read-write, named ib-stop-loss, and even then the description says it places and cancels conditional orders only when an execute flag is passed, with dry-run as the default.

So the design is defence in depth rather than defence once. The account permission is the outer boundary, and a command-line flag is the inner one. Both have to agree before an order exists.

This is the part that makes the rest of the feature list reasonable. The portfolio features described at the top include finding roll candidates for expiring shorts, flagging earnings risk and generating action reports, and all three of those are analysis rather than execution. The one write path is a stop loss, and it is gated.

Connecting requires TWS or IB Gateway running locally, which the requirements list as optional because the market data skills work without any broker connection at all.

Scores out of ten and out of eleven, with no rubric

The worked example in the README is the most informative thing in it, and it contains a problem.

Ask the system to scan five tickers for bullish trends and then check the top picks for PMCC suitability, and the documented reply is a bullish score of 8 out of 10 for NVDA followed by a PMCC score of 9.2 out of 11, with a LEAPS call at delta 0.82, a short call at delta 0.18, a net debit of $5,420 and an annual yield of 47 percent.

The chain of reasoning is shown too: the bullish scanner runs, the top scores are filtered, then the PMCC scanner runs on what survived. That is the behaviour you want, and it is the reason a single sentence produces a spread with legs.

The problem is the scoring. One scanner is out of ten and the other is out of eleven, and neither the skill tables nor the example says what a point represents. A 9.2 out of 11 does not obviously mean better than an 8 out of 10, and there is no way to tell from the output whether the scale is a weighted sum of named criteria or something else.

The numbers underneath the score are checkable and the score is not. Delta, strike, net debit and yield are all things you can recompute yourself. The composite is the part you are being asked to trust.

The correlation example is more honest by contrast, because it reports a pair and lets you interpret it: near-zero correlation for one name, and 0.86 between two others described as offering little diversification benefit between them.

The README asks for Python 3.12 and the manifest demands 3.13

Two numbers, in two places, and they do not match.

The requirements section says Python 3.12 or newer, and the MCP installation step repeats 3.12 or newer. The project manifest declares requires-python as greater than or equal to 3.13.

The rest of the tooling has already moved to 3.13. The lint configuration targets that version, the dev dependency group pins pytest at version 9 and the runtime at Python 3.13, and there is a .python-version file in the repository root, which is what uv and most version managers read to pick an interpreter.

So the manifest and the tooling agree with each other and the README is the outlier. On a machine with only 3.12 the install will fail at resolution rather than at import, which is at least a clear failure rather than a subtle one.

Worth noting alongside this: the pandas-ta dependency is pinned to a pre-release build, which is the version string carrying a beta suffix. Whatever that library is doing, the project is choosing a beta of it, and that is a maintenance decision with consequences on a NumPy 2 floor.

The rest of the dependency list is unremarkable and well chosen for the job: pandas and NumPy at 2 or newer, scipy, an async Interactive Brokers client, a market calendar library, plotting, and the reportlab and pypdf pair for producing and reading PDFs.

The test suite queries live market data and needs reruns

The pytest configuration is the most candid thing in the repository, and it is a comment.

Tests run in asyncio auto mode against the tests directory, with a marker for manual tests that require a live broker connection and are deselected by default. The default options are a marker expression excluding the manual tests, two reruns, and a two second delay between them.

The comment above explains why: many tests query live market-data APIs, which intermittently rate-limit or time out, and retrying absorbs those transients while a deterministic failure still fails on every attempt.

That is a better position than the alternative, which is mocking everything and finding out at runtime that the API response shape changed. The cost is that the suite is not hermetic, so it will be slow, it will be flaky under load, and it cannot be trusted as a gate the way a hermetic suite can.

It also tells you something about how the project is built. These are not unit tests over pure functions; they are integration checks against the real endpoints, which is the only way to know the parsers handle the current response format.

The MCP entry point is a console script pointing at the server module, the build backend is hatchling, and the wheel packages both the main library under src and the MCP server directory.

Where the data comes from, and which parts need a key

The stack of data sources is visible in the dependency list and explains what works without what.

Quotes, volume, market cap and the 52-week range come from the Yahoo Finance client, which is a community-maintained wrapper over that service's endpoints rather than a vendor API with a contract. Fundamentals, earnings and the Piotroski F-score come from the same place, as does historical OHLCV. Insider activity is Form 4 data from the SEC.

Option chain detail and institutional whale activity come from a different provider entirely, and that one needs an API key. The whale-hunting skill says so explicitly. Option strikes, bids, asks, volume, open interest and implied volatility therefore depend on a service you have to sign up for.

The broker connection is the third source, through an async Interactive Brokers client talking to a local TWS or Gateway.

Indicators are computed rather than fetched: RSI, MACD, Bollinger Bands, moving averages, ATR and ADX for technical analysis, and Black-Scholes for the Greeks, with volatility, beta, value at risk, drawdown and the Sharpe ratio for risk assessment. Spread analysis covers verticals, diagonals, straddles, strangles and iron condors. Earnings dates come with before-market and after-market timing and estimates attached.

Reports go out as PDF, with plotly for charts and a markdown parser in the pipeline, and there are two sample reports checked into the repository under examples, one of which has the account identifier redacted in its filename.

Twenty-three tools or twenty-five skills

The documentation has an unresolved count, and it is worth flagging before you build an integration around a number.

The MCP section says the server exposes 23 trading analysis tools. The skills section is headed Available Skills (25).

Counting the visible tables does not settle it either. Market data lists seven skills, analysis lists four, scanners lists three, the read-only portfolio group names nine and the read-write group names one. That is twenty-four from the lists that are readable, against a heading that claims twenty-five, and the portfolio table is cut off partway through in the copy of the page available here.

So the honest position is that the count is unresolved: two different totals appear in the same document, and the lists do not reconcile to either of them without the missing part.

What is not in doubt is the shape of the catalogue. Market data and analysis skills work with no broker connection and, apart from the option chain provider, no credential of any kind. Scanners sit alongside them. Everything prefixed ib- needs TWS or Gateway, and everything prefixed ib- except one is read-only.

If you are writing an agent loop against this, enumerate the tools the server actually advertises at runtime rather than trusting either number in the prose.

Against writing the same scripts yourself

The alternative is closer than it looks, because this project's own dependencies are the alternative. yfinance for quotes, an Interactive Brokers client for the account, scipy for the maths. A focused version of what you get here is a weekend of work.

What you would build is the parts you use. A quote function, an option chain fetcher, a Greeks calculation, maybe a scanner over a list of tickers. That code is short, you can see exactly what it does with your credentials, and it will never ask a language model to interpret your intent.

What you would not have is the layer that decides which of those to call. Here the routing is the point: one sentence produces a bullish scan, a filter, a PMCC check and a spread with legs, without you writing the glue. Add twenty-odd skills and a portfolio read path and the value becomes breadth rather than automation.

The trade is ownership against convenience. Your own scripts fail loudly and cost nothing to run. These skills cost a model call and return prose containing a number you then have to decide whether to verify, and the composite scores do not come with a stated method.

Two things change that calculus. If you already run TWS, the broker integration is the part you would not write and might not enjoy writing. And if you want the same analysis in natural language across a desk rather than in a script, the conversation layer is what you are paying for.

Whichever way you go, treat the output as data to check. Delta and net debit can be recomputed by hand; a score out of eleven cannot.

Editorial conclusion

trading_skills fits an options trader who already lives in Interactive Brokers, wants a scanner that runs against real chain data rather than a screenshot, and is willing to read the underlying code before letting a model near the account. It does not fit someone who wants a signal or an opinion, because the outputs are data and the scoring is unexplained. Verify two things before you connect a broker account: that your TWS connection is on a read-only API level, since nine of the ten broker skills assume that, and whether the Python floor in the README or the one in the manifest matches your machine, because the two disagree. The MIT licence is permissive; the version is 0.18.8 and the last push was on 2026-09-28.

Frequently asked questions

Official sources

1. Issues
2. License: MIT
3. README
4. Releases
5. staskh/trading_skills on GitHub