quantitats-mcp
OfficialClick on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@quantitats-mcp show my open orders on venue BTC-USD"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
quantitats-mcp
An MCP server over the published trading API. Every /v1 endpoint an API key
can reach is a tool; the credentials come from the environment and never from a
command line.
It is a client and nothing more. It holds no state, caches nothing, and adds no endpoint of its own — what a model can do through it is exactly what the key it was given can do, which is the property that makes it safe to hand to one.
What it exposes
26 tools, generated from src/catalogue.ts, which is the
whole surface:
Area | Tools | Scope |
Bots |
|
|
Market data |
|
|
Trading |
|
|
Scripts |
|
|
Portfolio |
|
|
Streams |
| any valid key |
A scope is not implied by another: a key that lists and starts bots needs both
bots:read and bots:write.
Arguments use the API's own vocabulary, not a friendlier one, because the API is
strict where it matters: an order's side is BUY or SELL, a status filter is
one of the upper-case statuses, and an order type is one of the seven the API
places (MARKET, LIMIT, LIMIT_MAKER, STOP_LOSS, STOP_LOSS_LIMIT,
TAKE_PROFIT, TAKE_PROFIT_LIMIT). A bot's name is trimmed and lower-cased
before it goes into a path, as the API stores it — a stop addressed to Alpha
would otherwise answer 204 and stop nothing. list_open_orders takes no
filters, because its route reads none; list_orders is the one that filters.
Related MCP server: Financial Modeling Prep MCP Server
Rate limits
The edge meters the published API per key, in six buckets, and the figures differ by three orders of magnitude. Every tool states its own in its description, so a model reads the budget before it plans rather than discovering it by being refused.
Bucket | Allowance | Tools |
| 932 / minute |
|
| 600 / minute | the bot, script and order reads |
| 60 / minute |
|
| 30 / minute |
|
| 60 / hour |
|
| 60 / hour |
|
Three of those are worth knowing before writing a client:
venue-publicis 60 an hour, not a minute. Those two endpoints serve a cached copy and never reach a venue, so the allowance is the cache's lifetime rather than a polling budget. Read an instrument list once and keep it; for prices more often, read the venue's own public API, which is free and authoritative.venue-privatespends your allowance twice. Each call reaches the venue with your own key, so it counts there as well as here — and a balances read naming no venue is one request here and up to eleven there.defaultandcontrol-planeshare the/v1/botsprefix. Reading is 600 a minute and writing is 30. Which bucket a path falls into is not derivable from the path, which is whysrc/catalogue.tsstates it per endpoint.
Windows are fixed, not sliding: a bucket refills at the top of the minute or the hour, so the whole allowance can be spent at once and then waited out.
The server does three things with this:
Says it up front — in every tool description, and in the instructions a client reads before its first call.
Counts locally and refuses before dialling, so a model that would have blown through a bucket gets a "wait 34s, nothing was spent" it can recover from inside the same window. The counter aligns to the same wall-clock boundaries the edge uses. It is not a security control and errs towards allowing — the edge is the authority.
Reports what is left, from the edge's own
x-ratelimit-*headers, but only once a tenth of the bucket remains. A note on every call trains a reader to skip the line, and then the one that matters is skipped too.
src/ratelimits.ts mirrors the deployed policy, and
test/ratelimits.test.ts reads that policy and fails
when a figure moves on one side only.
What it deliberately does not expose
Stored venue keys, API keys themselves, plan and billing, and administration. No scope grants those and there is no tool for them, so this is not a gap to fill later. A key can use stored venue keys to trade and can never read, add, replace or delete one — which is what keeps a leaked key from re-pointing the account at somebody else's venue account.
Live streams are discovery only. A stream is a long-lived connection and cannot
be read through a request-and-response tool call, so list_streams says what
exists and the list tools answer the same questions.
Configuration
Every setting is an environment variable; see .env.example.
Two are needed — the key id and its key material:
QUANTITATS_API_KEY_ID=ak_...
QUANTITATS_API_PRIVATE_KEY_FILE=/run/secrets/api-key.pem # Ed25519, or:
QUANTITATS_API_SECRET_FILE=/run/secrets/api-secret # HMAC-SHA256Requests go to https://api.quantitats.com/v1/* — list_bots dials and signs
https://api.quantitats.com/v1/bots. QUANTITATS_API_URL overrides the host for
a self-hosted or staging deployment and takes an origin with no path: the
/v1 is on the endpoint, not the base, so one configuration cannot disagree with
the paths the catalogue signs. A base carrying a path is refused at startup,
because a segment that is in the dialled URL but not in the signed string is a
signature that never verifies.
Credentials are read from the environment, or better from a file the environment points at, and never from argv — an argv is readable by every process on the machine and lands in shell history, while an MCP client launches this process with an env block of its own.
The algorithm is inferred from whichever key material is present, and
QUANTITATS_API_ALG settles it only when both are.
Two optional narrowings, both off by default:
QUANTITATS_MCP_READ_ONLY=truehides every tool that changes anything.QUANTITATS_MCP_SCOPES=bots:read,trade:readadvertises only the tools those scopes reach. A key's scopes cannot be read back from any endpoint, so this is stated rather than fetched; leaving it unset advertises everything and lets the server refuse.
Neither is a security boundary — the key's own scopes are. They stop a model spending a call to learn what the manifest could have told it.
Running it
npm install
npm run check # typecheck, tests, build
npm run build # dist/server.mjs, one bundled file with a shebangThen point an MCP client at the built file:
{
"mcpServers": {
"quantitats": {
"command": "node",
"args": ["/path/to/mcp/dist/server.mjs"],
"env": {
"QUANTITATS_API_KEY_ID": "ak_...",
"QUANTITATS_API_SECRET_FILE": "/run/secrets/api-secret"
}
}
}
}A configuration problem is reported on stderr and exits 2, naming the variable to set. stdout carries JSON-RPC and nothing else.
From the image
docker run -i --rm \
-e QUANTITATS_API_KEY_ID=ak_... \
-e QUANTITATS_API_SECRET=... \
<registry>/<owner>/<repo>/mcp:latest-i is not optional: the transport is stdin and stdout, so without a stdin the
process has nothing to read and exits having answered nothing. There is no port
and no healthcheck — this is a tool a client launches, not a service that listens.
Versioning
One version per build, derived from git (scripts/version.mjs),
stamped into the bundle and reported to a client as serverInfo.version:
Built at | Version |
a |
|
any other commit |
|
an uncommitted tree | the above plus |
no repository (a tarball, or the image build) |
|
-dev, not +dev: semver sorts a prerelease below the plain version, which is
the direction that makes "is this newer than 0.2.0" answerable.
CI computes the version once and passes it to every architecture as a build
argument, so the image tag and the string a client reads cannot disagree — and it
has to be passed in, because .dockerignore excludes .git and an image build
cannot see the repository. Container tags replace the semver + with _, which a
reference may not carry.
Nothing creates a git tag automatically. A release is git tag v1.2.3 && git push --tags; CI that tagged on its own would make the version history a function of
merge order rather than of anybody's decision.
CI
.github/workflows/ci.yml runs on a Gitea forge,
written in GitHub Actions syntax because Gitea reads .github/workflows too.
Do not add a .gitea/workflows directory — precedence is
first-directory-exists-wins, so it would silently stop everything in here from
running while still looking fine.
On a pull request: typecheck, test, bundle. Nothing is published.
On a push to
main: the same, then a multi-architecture image taggedlatest,sha-<sha>and the dev version.On a
v*tag: the same, tagged1.2.3,1.2,1andlatest.
No job asks for an architecture-specific runner. Every runs-on is
ubuntu-latest, so any runner on the forge can take any job — a label like
ubuntu-latest-amd64 is a request, and with nothing carrying it a job does not
fail, it queues until the whole run times out.
The price is emulation: QEMU is installed and buildx builds every platform in one invocation, pushing the manifest directly. That is affordable here because nothing in this image is architecture-specific — the output is JavaScript, so an emulated build produces the same bytes as a native one and costs only time.
arm64 is still opt-in, via BUILD_ARM=true as an environment or repository
variable, because emulating it takes several times what amd64 does and most
pushes do not need it.
Publishing needs REGISTRY_USERNAME / REGISTRY_PASSWORD secrets; the built-in
job token cannot write to Gitea's registry.
How a request is signed
The scheme is the API's, restated in src/signing.ts. A
signature is taken over six lines joined with \n, no trailing newline:
<METHOD, uppercased>
<URL path, exactly as dialled>
<raw query string, exactly as sent, "" when there is none>
<X-Timestamp>
<X-Nonce>
<lowercase hex SHA-256 of the raw body>and travels as X-Signature, base64, alongside X-Key-Id, X-Timestamp and
X-Nonce. Nothing is normalised beyond uppercasing the method: the query is not
sorted, the path is not re-escaped, and the bytes that are hashed are the bytes
that are sent. Re-serialising a body between signing it and sending it is the
classic way to break a signature, and this client does not.
Two things are worth knowing if you are debugging a refusal:
The path signed is the public one.
https://api.quantitats.com/v1/botsis the address,/v1/botsis the second canonical line, and there is no prefix to add or strip. The internal/apiis never dialled or signed.For an HMAC key the signing key is the decoded secret, not the base64 text you were shown. This client decodes it for you, and refuses text that is not base64 rather than signing with whatever could be salvaged from it.
Tests
npm test162 tests, all hermetic — nothing reaches the network or a real deployment.
The two that carry the most weight:
test/signing.test.tspins the worked example the API publishes: the body hash, the canonical string's exact bytes and length, its SHA-256, and the two signatures. The Ed25519 case verifies the published signature under the published public key, since only the public half was ever published — which pins the same thing, because a signature verifies only over the exact string it was made from. If one of these fails, this client and the server disagree about what a request means.test/fake-api.tsis not a stub. It rebuilds the canonical string from the request as it arrived and refuses a signature that does not verify over it, exactly as the API does, and it dropsAuthorizationthe way the published listener does.test/client.test.tsandtest/server.test.tsrun the whole path against it — a real MCP client, this server, a real signature, a real verification.
test/catalogue.test.ts holds the other line: the method, path and scope of
every tool, copied from the published endpoint reference rather than derived
from the catalogue, so a guard that moves in the API shows up here as a failure
rather than as a 403 someone hits later. Its "what the API accepts" block does the
same for the argument schemas — the sides, statuses, order types and loss-limit
shapes the handlers take, and a bot's name as they store it.
test/naming.test.ts checks the tool manifest the server actually serves —
every title, description and argument description, plus the instructions a
client reads before its first call — against the denylist, since a manifest is
squarely something a user observes.
Layout
src/signing.ts the six-line canonical string and the two primitives
src/config.ts the environment, validated, with the fix in every message
src/catalogue.ts every endpoint: method, path, scope, argument schema
src/client.ts arguments -> signed request -> answer or a readable failure
src/server.ts one MCP tool per catalogue entry
src/main.ts stdio transport; stderr for humans, stdout for JSON-RPCAdding an endpoint means adding one entry to src/catalogue.ts and its row to
the table in test/catalogue.test.ts. There is no second place.
Available Tools
26 toolscancel_orderCancel one orderADestructive
Withdraws one resting order, addressed by the client order id it has carried since it was filed — which is the identifier it has before the venue has answered at all.
Requires the trade:write scope.
Rate limit: 932 requests per minute for your key, shared across every tool in the trade-write group. This is the average of what the supported venues themselves allow one account, so it is not a figure to design around — a strategy that needs more than this needs the venue directly.
Inputs: clientOrderId (required).
cancel_ordersCancel many ordersADestructive
Withdraws every open order matching the filter, and answers with what happened to each one. WITH NO FILTER THIS CANCELS EVERYTHING ON THE ACCOUNT, including orders the account's bots are working — pass origin=manual to spare those. Narrow it before calling it.
Requires the trade:write scope.
Rate limit: 932 requests per minute for your key, shared across every tool in the trade-write group. This is the average of what the supported venues themselves allow one account, so it is not a figure to design around — a strategy that needs more than this needs the venue directly.
Inputs: bot, origin, symbol, exchange.
create_botCreate a botA
Creates and starts a bot running one of the account's scripts. Answers 409 if the name is taken and 403 if the plan's bot limit is reached, naming the limit. Mode defaults to paper; sim settings are refused on a live bot rather than ignored. A live bot trades real funds.
Requires the bots:write scope.
Rate limit: 30 requests per minute for your key, shared across every tool in the control-plane group. Changing configuration is metered far more tightly than reading it. Creating, reconfiguring, stopping and deleting all share this budget, so make one considered change rather than a sequence of adjustments.
Inputs: name (required), script (required), exchanges (required), sim, +3 more.
create_scriptCreate a scriptA
Stores a new strategy script. Answers 409 if the name is already in use and 403 if the plan's script allowance is used, naming the plan and the count. Editing or deleting a script is never counted.
Requires the scripts:write scope.
Rate limit: 30 requests per minute for your key, shared across every tool in the control-plane group. Changing configuration is metered far more tightly than reading it. Creating, reconfiguring, stopping and deleting all share this budget, so make one considered change rather than a sequence of adjustments.
Inputs: name (required), script (required).
delete_scriptDelete a scriptADestructive
Removes a script from the account's library.
Requires the scripts:write scope.
Rate limit: 30 requests per minute for your key, shared across every tool in the control-plane group. Changing configuration is metered far more tightly than reading it. Creating, reconfiguring, stopping and deleting all share this budget, so make one considered change rather than a sequence of adjustments.
Inputs: name (required).
get_bot_analyticsRead one bot's performanceARead-onlyIdempotent
That bot's realized profit and loss and its fill statistics, optionally over a time window. Money figures are decimal strings keyed by asset or symbol; add two together only when they share one.
Requires the bots:read scope.
Rate limit: 600 requests per minute for your key, shared across every tool in the default group. Ten a second. These read stored records rather than calling a venue, which is why they are cheap.
Inputs: name (required), since, until.
get_bot_configRead a bot's settingsARead-onlyIdempotent
That bot's settings: the fields its script declares, the values this bot overrides, its run mode, its simulator settings if it is a paper bot, and its loss limit (a number, or an object with max_loss).
Requires the bots:read scope.
Rate limit: 600 requests per minute for your key, shared across every tool in the default group. Ten a second. These read stored records rather than calling a venue, which is why they are cheap.
Inputs: name (required).
get_scriptRead a scriptARead-onlyIdempotent
One script's source, with when it was created and last changed.
Requires the scripts:read scope.
Rate limit: 600 requests per minute for your key, shared across every tool in the default group. Ten a second. These read stored records rather than calling a venue, which is why they are cheap.
Inputs: name (required).
get_script_configRead a script's settingsARead-onlyIdempotent
The settings that script declares — each field's name, type, default and hint — which is what a bot running it may override.
Requires the scripts:read scope.
Rate limit: 600 requests per minute for your key, shared across every tool in the default group. Ten a second. These read stored records rather than calling a venue, which is why they are cheap.
Inputs: name (required).
get_tickerGet the current priceARead-onlyIdempotent
The current price for one symbol on one venue.
Requires the market:read scope.
Rate limit: 60 requests per hour for your key, shared across every tool in the venue-public group. Sixty an hour, because this serves a cached copy and the cache is good for the hour. Read an instrument list once and keep it. For prices more often than this, read the venue's own public API — it is free, authoritative, and answers far more often than this will.
Inputs: venue (required), symbol (required).
get_venue_balancesList one venue's balancesARead-onlyIdempotent
Balances at one venue.
Requires the portfolio:read scope.
Rate limit: 60 requests per minute for your key, shared across every tool in the venue-private group. Each of these calls the venue with your own key and spends your allowance there as well as here, so do not poll it. Name a venue when you only need one. For anything you would otherwise poll for, follow the order stream, which reports a fill when it happens instead of being asked whether one has.
Inputs: venue (required).
list_balancesList balancesARead-onlyIdempotent
Balances across every venue the account holds keys for.
Requires the portfolio:read scope.
Rate limit: 60 requests per minute for your key, shared across every tool in the venue-private group. Each of these calls the venue with your own key and spends your allowance there as well as here, so do not poll it. Name a venue when you only need one. For anything you would otherwise poll for, follow the order stream, which reports a fill when it happens instead of being asked whether one has.
Inputs: no named parameters.
list_bot_ordersList one bot's ordersARead-onlyIdempotent
Every order that bot has placed, open and historic, newest first. Readable even for a bot that has been stopped. An unknown bot answers with an empty list, not an error.
Requires the bots:read scope.
Rate limit: 600 requests per minute for your key, shared across every tool in the default group. Ten a second. These read stored records rather than calling a venue, which is why they are cheap.
Inputs: name (required), side, limit, since, +4 more.
list_botsList botsARead-onlyIdempotent
Every bot on the account: its state and run mode, the script it runs, and a summary of the fleet. Also returns the scripts and run modes a new bot can be created with.
Requires the bots:read scope.
Rate limit: 600 requests per minute for your key, shared across every tool in the default group. Ten a second. These read stored records rather than calling a venue, which is why they are cheap.
Inputs: no named parameters.
list_instrumentsList a venue's instrumentsARead-onlyIdempotent
Every symbol that venue lists, with its tick and lot rules. Public market structure — read this before placing an order, because a price or quantity off the venue's grid is refused by the venue.
Requires the market:read scope.
Rate limit: 60 requests per hour for your key, shared across every tool in the venue-public group. Sixty an hour, because this serves a cached copy and the cache is good for the hour. Read an instrument list once and keep it. For prices more often than this, read the venue's own public API — it is free, authoritative, and answers far more often than this will.
Inputs: venue (required).
list_open_ordersList open ordersARead-onlyIdempotent
Every order across the account that can still trade, from bots and from manual placement alike, each one carrying which bot placed it. This is the account's own view of the book. It takes no filters: filter the result yourself, or use list_orders, which does filter.
Requires the trade:read scope.
Rate limit: 600 requests per minute for your key, shared across every tool in the default group. Ten a second. These read stored records rather than calling a venue, which is why they are cheap.
Inputs: no named parameters.
list_ordersList order historyBRead-onlyIdempotent
The account's order history, filtered and paged. Page with the nextBefore the response carries.
Requires the trade:read scope.
Rate limit: 600 requests per minute for your key, shared across every tool in the default group. Ten a second. These read stored records rather than calling a venue, which is why they are cheap.
Inputs: bot, side, limit, since, +6 more.
list_positionsList open positionsARead-onlyIdempotent
Open derivative positions across the account.
Requires the portfolio:read scope.
Rate limit: 60 requests per minute for your key, shared across every tool in the venue-private group. Each of these calls the venue with your own key and spends your allowance there as well as here, so do not poll it. Name a venue when you only need one. For anything you would otherwise poll for, follow the order stream, which reports a fill when it happens instead of being asked whether one has.
Inputs: no named parameters.
list_scriptsList scriptsARead-onlyIdempotent
The account's strategy scripts, with the limits the editor enforces on them.
Requires the scripts:read scope.
Rate limit: 600 requests per minute for your key, shared across every tool in the default group. Ten a second. These read stored records rather than calling a venue, which is why they are cheap.
Inputs: no named parameters.
list_streamsList live streamsARead-onlyIdempotent
The live streams this deployment serves and the scope each needs. Discovery only — a stream is a long-lived connection and cannot be read through a tool call, so use this to find out what exists and read the same data through the list tools.
Requires the key to be valid.
Rate limit: 60 requests per hour for your key, shared across every tool in the ws-ticket group. Listing the streams shares a budget with opening one. Read it once; it does not change while a key lives.
Inputs: no named parameters.
list_venue_open_ordersList what a venue says is openARead-onlyIdempotent
One venue's own view of the account's resting orders, including any placed from the venue's own app. Deliberately separate from list_open_orders: comparing the two is how a disagreement becomes visible.
Requires the trade:read scope.
Rate limit: 60 requests per minute for your key, shared across every tool in the venue-private group. Each of these calls the venue with your own key and spends your allowance there as well as here, so do not poll it. Name a venue when you only need one. For anything you would otherwise poll for, follow the order stream, which reports a fill when it happens instead of being asked whether one has.
Inputs: venue (required), symbol.
list_venuesList venuesARead-onlyIdempotent
The venue list and, for each, whether the account has keys stored for it and whether the plan permits it. That is account state, which is why it costs trade:read rather than market:read.
Requires the trade:read scope.
Rate limit: 600 requests per minute for your key, shared across every tool in the default group. Ten a second. These read stored records rather than calling a venue, which is why they are cheap.
Inputs: no named parameters.
place_orderPlace an orderA
Submits one order with real funds and answers with it as the venue acknowledged it. Quantities and prices are decimal STRINGS, not numbers, so nothing is lost to floating point. A LIMIT order needs a price; a stop or take-profit order needs a stopPrice. Check list_instruments first: a price or size off the venue's grid is refused.
Requires the trade:write scope.
Rate limit: 932 requests per minute for your key, shared across every tool in the trade-write group. This is the average of what the supported venues themselves allow one account, so it is not a figure to design around — a strategy that needs more than this needs the venue directly.
Inputs: side (required), type (required), symbol (required), exchange (required), +6 more.
stop_botStop a botADestructive
Stops the bot and retires it. Its orders and analytics remain readable afterwards. This does not cancel orders the bot already has resting at a venue — use cancel_orders for that.
Requires the bots:write scope.
Rate limit: 30 requests per minute for your key, shared across every tool in the control-plane group. Changing configuration is metered far more tightly than reading it. Creating, reconfiguring, stopping and deleting all share this budget, so make one considered change rather than a sequence of adjustments.
Inputs: name (required).
update_bot_configReplace a bot's settingsADestructiveIdempotent
Replaces the overrides — a full replacement, not a merge, so send every override the bot should keep — and RESTARTS the bot. Orders already resting at a venue are not cancelled by this.
Requires the bots:write scope.
Rate limit: 30 requests per minute for your key, shared across every tool in the control-plane group. Changing configuration is metered far more tightly than reading it. Creating, reconfiguring, stopping and deleting all share this budget, so make one considered change rather than a sequence of adjustments.
Inputs: name (required), config (required), sim, killSwitch.
update_scriptReplace a scriptADestructiveIdempotent
Replaces a script's whole source. Bots already running it keep running the version they started with until they are restarted. An edit that changes the settings the script declares is refused with a 409; save it under a new name instead.
Requires the scripts:write scope.
Rate limit: 30 requests per minute for your key, shared across every tool in the control-plane group. Changing configuration is metered far more tightly than reading it. Creating, reconfiguring, stopping and deleting all share this budget, so make one considered change rather than a sequence of adjustments.
Inputs: name (required), script (required).
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 26 tools
Most tools target a distinct resource+action and the descriptions carefully differentiate them (e.g. list_open_orders vs list_venue_open_orders vs list_bot_orders, and get_bot_config vs get_script_config). However, the cluster of order-listing tools and the cancel_order/cancel_orders singular-vs-plural pair require close reading to avoid misselection.
The set uses a consistent verb_noun snake_case pattern (list_*, get_*, create_*, update_*, delete_*, place_order, cancel_*). The only real deviation is cancel_order vs cancel_orders, where singular/plural carries meaning but is easy to misread.
At 26 tools it sits at the heavy end, but the domain genuinely spans bots, scripts, orders, portfolio, market data, and streams, and each tool maps to a distinct operation. It is slightly over-scoped rather than padded.
Coverage is strong: full script CRUD, bot lifecycle (create/stop/config/analytics/orders), order placement and both single and bulk cancellation, plus portfolio and market reads. Minor gaps like an order-modify/replace or single-order status tool exist but agents can work around them.
Maintenance
Related MCP Connectors
Unified financial infrastructure connecting AI agents directly to trade live/demo brokerage accounts, Web3 non-custodial wallets, real-time market data across equities, ETFs, crypto, forex, options, DeFi swaps, and prediction markets, institutional research feeds, and algorithmic strategy backtesters.
Build, backtest, and deploy quantitative trading strategies from your AI agent.
Live crypto + IDX stock market intelligence for AI agents — 19 tools, no API key.
Guardrails for trading agents. Built-in risk management, 100+ tools for strategy R&D, 12+ venues.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceEnables AI assistants to interact with QuantConnect's algorithmic trading platform to create projects, write trading strategies, run backtests, perform optimizations, and deploy algorithms to live trading through the QuantConnect API.Apache 2.0
- AlicenseNot gradedqualityAmaintenanceEnables AI assistants to access and analyze financial data such as stocks, ETFs, crypto, forex, commodities, company fundamentals, financial statements, and market insights through 250+ configurable tools.558 npmApache 2.0
- AlicenseNot gradedqualityAmaintenanceExposes 250+ financial data tools to AI assistants, enabling access and analysis of stocks, company fundamentals, ETFs, crypto, forex, commodities, economics, and market insights.558 npmApache 2.0
- AlicenseNot gradedqualityAmaintenanceExposes 250+ financial data tools to AI assistants, enabling access and analysis of stocks, company fundamentals, ETFs, crypto, forex, commodities, economic indicators, and market insights.558 npmApache 2.0