Skip to main content
Glama
quantitats-mcp

quantitats-mcp

Official
by quantitats

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

list_bots, create_bot, stop_bot, get_bot_config, update_bot_config, list_bot_orders, get_bot_analytics

bots:read / bots:write

Market data

list_instruments, get_ticker

market:read

Trading

list_venues, list_open_orders, list_orders, list_venue_open_orders, place_order, cancel_order, cancel_orders

trade:read / trade:write

Scripts

list_scripts, get_script, get_script_config, create_script, update_script, delete_script

scripts:read / scripts:write

Portfolio

list_balances, get_venue_balances, list_positions

portfolio:read

Streams

list_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

trade-write

932 / minute

place_order, cancel_order, cancel_orders

default

600 / minute

the bot, script and order reads

venue-private

60 / minute

list_balances, get_venue_balances, list_positions, list_venue_open_orders

control-plane

30 / minute

create_bot, stop_bot, update_bot_config, create_script, update_script, delete_script

venue-public

60 / hour

list_instruments, get_ticker

ws-ticket

60 / hour

list_streams

Three of those are worth knowing before writing a client:

  • venue-public is 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-private spends 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.

  • default and control-plane share the /v1/bots prefix. Reading is 600 a minute and writing is 30. Which bucket a path falls into is not derivable from the path, which is why src/catalogue.ts states 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:

  1. Says it up front — in every tool description, and in the instructions a client reads before its first call.

  2. 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.

  3. 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-SHA256

Requests 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=true hides every tool that changes anything.

  • QUANTITATS_MCP_SCOPES=bots:read,trade:read advertises 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 shebang

Then 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 v1.2.3 tag on HEAD

1.2.3

any other commit

0.1.0-dev.<commits>+<sha>

an uncommitted tree

the above plus .dirty

no repository (a tarball, or the image build)

0.1.0+unknown

-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 tagged latest, sha-<sha> and the dev version.

  • On a v* tag: the same, tagged 1.2.3, 1.2, 1 and latest.

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/bots is the address, /v1/bots is the second canonical line, and there is no prefix to add or strip. The internal /api is 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 test

162 tests, all hermetic — nothing reaches the network or a real deployment.

The two that carry the most weight:

  • test/signing.test.ts pins 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.ts is 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 drops Authorization the way the published listener does. test/client.test.ts and test/server.test.ts run 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-RPC

Adding 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 tools
cancel_orderCancel one orderA
Destructive

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 ordersA
Destructive

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 scriptA
Destructive

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 performanceA
Read-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 settingsA
Read-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 scriptA
Read-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 settingsA
Read-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 priceA
Read-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 balancesA
Read-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 balancesA
Read-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 ordersA
Read-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 botsA
Read-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 instrumentsA
Read-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 ordersA
Read-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 historyB
Read-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 positionsA
Read-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 scriptsA
Read-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 streamsA
Read-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 openA
Read-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 venuesA
Read-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 botA
Destructive

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 settingsA
DestructiveIdempotent

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 scriptA
DestructiveIdempotent

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

    A3.9/5.0

    Scored across 26 tools

    Disambiguation4/5

    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.

    Naming Consistency4/5

    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.

    Tool Count4/5

    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.

    Completeness4/5

    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

    ActivityStale
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      D
      maintenance
      Enables 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
    • A
      license
      Not graded
      quality
      A
      maintenance
      Enables 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 npm
      Apache 2.0
    • A
      license
      Not graded
      quality
      A
      maintenance
      Exposes 250+ financial data tools to AI assistants, enabling access and analysis of stocks, company fundamentals, ETFs, crypto, forex, commodities, economics, and market insights.
      558 npm
      Apache 2.0
    • A
      license
      Not graded
      quality
      A
      maintenance
      Exposes 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 npm
      Apache 2.0