quantra-mcp
quantra-mcp lets you build validated Quantra engine requests from trade terms and presets, forward them to a QuantLib-based pricing engine, and receive engine numbers plus the exact replayable request/response.
Discover engine metadata, health, endpoints, schemas, enums, examples, and calendar holidays/business days/date advances.
Build, bootstrap, sample, and query interest-rate curves from quote strips or pasted tables using named market-convention presets.
Price swaps, OIS, fixed/floating/zero/callable bonds, FRAs, caps/floors, swaptions, CDS, equity options, and ZC/YoY inflation products (plus structured notes per README).
Run raw validated passthrough requests to engine POST endpoints via
engine_request.Calibrate swaption SABR/Hull-White models and sample volatility surfaces where supported.
Compute analytics by repricing: swap DV01, key-rate ladders, scenarios, and fair rates; compare/reprice/explain results.
Store temporary curves, indices, or markets in session scratch and reference them later.
Enforce market-data provenance rules: numbers must be user-provided, sourced, from examples, or session-stored; no invented data. Every result echoes the exact request and engine response.
Click 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., "@quantra-mcp price a 10Y USD SOFR swap using my pasted market data"
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.
quantra-mcp
An MCP server that is a client of the Quantra pricing engine's JSON API (QuantLib-based, open source): it builds correct requests from trade terms and named market-convention presets, forwards them, and returns the engine's numbers plus the exact request that was sent. It computes nothing itself; every number comes from the engine.
agent ──(MCP: stdio / streamable HTTP)──▶ quantra-mcp ──(HTTP/JSON)──▶ Quantra engineUse the public server
Hosted instance, no account: https://mcp.quantra.io/mcp (prices on the same
engine as api.quantra.io; open, rate-limited per MCP session; session
scratch is per MCP session, in memory, bounded, never persisted).
claude.ai: Settings → Connectors → Add custom connector → URL
https://mcp.quantra.io/mcp → ask Claude to price a trade.
Claude Code:
claude mcp add --transport http quantra https://mcp.quantra.io/mcpClaude Desktop: Settings → Connectors → Add custom connector → URL
https://mcp.quantra.io/mcp(the same custom connector as claude.ai; no config file)Cursor: add
{"mcpServers": {"quantra": {"url": "https://mcp.quantra.io/mcp"}}}to.cursor/mcp.jsonor~/.cursor/mcp.json
Per-client setup, the stdio form for a local engine, and project instructions for business users are in docs/clients.md.
Related MCP server: abacus
Run it yourself
Run an engine (one line, no account):
docker run -d --name quantra-engine -p 8080:8080 ghcr.io/joseprupi/quantra-server:0.14.0Run the server against it, from PyPI or from a clone:
QUANTRA_ENGINE_URL=http://localhost:8080 uvx quantra-mcp # stdio
git clone https://github.com/joseprupi/quantra-mcp && cd quantra-mcp && uv sync && uv run quantra-mcp --http --port 8765Or run engine and server together with Docker Compose (only port 8765 is published):
curl -O https://raw.githubusercontent.com/joseprupi/quantra-mcp/main/docker-compose.example.yml
docker compose -f docker-compose.example.yml up -d
curl http://localhost:8765/readyz
claude mcp add --transport http quantra http://localhost:8765/mcpEnv | Default | Meaning |
|
| Engine JSON gateway (self-hosted or |
|
| Per-request engine timeout in seconds. |
|
| Simultaneous engine calls (analytics fan-outs; |
|
|
|
| (empty) |
|
| (empty) |
|
The full table, hosted-mode hardening, security and limits: docs/configuration.md.
What it does
One tool per engine capability. Convenience tools turn trade terms and a preset into a complete engine request (dates the server cannot compute are resolved by the engine's calendar endpoints); raw passthrough takes any request body, validated against the vendored OpenAPI spec first. 44 tools, each with a title and MCP annotations (read-only / open-world hints):
Discovery and calendars (6):
quantra_meta,engine_schema(one endpoint, or all 29 without an argument),list_enums,calendar_holidays,calendar_business_days,calendar_advanceRaw passthrough (1):
engine_requestfor any of the 29 POST endpoints, including the six without a builder (swaption vol / model calibration, vol-surface sampling, inflation bootstrap, FX forward, cross-currency swap)Curves and presets (6):
preset(one or all),build_curve,build_value_curve,curve_from_pasted_table,build_query,bootstrap_curve; builder results carry a contentdigestPricing (15):
price_*for vanilla and OIS swaps, fixed / floating / zero-coupon / callable bonds, FRA, cap/floor, swaption, CDS, equity option, ZC and YoY inflation swaps, YoY cap/floor and structured notes (Monte Carlo, engine >= 0.12.0)Option quotes (2):
calibrate_implied_forwards(put-call-parity forwards, funding, dividend curve) andcalibrate_vol_surface(Andreasen-Huge or SVI Black surface with arbitrage checks and a repricing report); their dividend curve and VolSurfaceSpec feedprice_structured_note/price_equity_option(engine >= 0.14.0)Analytics by composition (4):
swap_dv01,key_rate_ladder,scenario,fair_rate, all finite differences of engine NPVs (compact by default;include_callsfor every replayable result)Reconciliation (3):
explain_method(cited engine methodology),compare_results,reprice_withSession scratch (2):
session_put,session(get / list / delete; private to the MCP session, in memory, bounded, never persisted)Examples (2):
list_examples,get_exampleover the engine's 245 vendored example requestsResources (docs, schemas, enums, examples, presets, pin, methodology) and 6 prompts
Catalog with every argument: docs/tools.md.
Rules
Market data comes from the user or from a cited source. The server has no market-data source and no vendor data; licensed curves and vols are never available server-side. Every tool that takes market numbers requires a
market_data_sourcedeclaration (user_pasted,user_file,sourced,engine_example,session); there is no value for invented data.sourced= obtained in the conversation from a trusted public publisher (central bank, treasury, FRED, exchange, index administrator, regulator filing, fund sponsor; any other site only after asking the user) or a data connector the user connected, and requiressources(what, value, as_of, url or connector, derived?), echoed in the result'sprovenance. The assistant will never type, estimate, recall or invent market data for a trade: without pasted or cited data, it says what is needed, in paste-able form, and stops.Every result echoes the exact
requestsent and the engine'sresponseverbatim, so any number can be replayed withcurlagainst the same engine. Engine errors pass through unchanged (400request wrong,422unpriceable); every failed result (ok: false) is also an MCP tool error (isError).Every convention applied is listed in
noteswith its source (a preset field, an engine fixture, or "market standard, not from an in-repo source").The shipped examples are request-shape references only; an example's market data is never reused for a user's trade.
Documentation
docs/clients.md: install and connect each client; project instructions for business users
docs/configuration.md: environment variables, hosted-mode settings, security and limits
docs/tools.md: tools, result shape, analytics, reconciliation, resources, prompts, examples catalog
docs/presets.md: the market-convention presets and their provenance
docs/walkthroughs.md: price a swap in three calls; build a curve from a strip
docs/development.md: gate, live checks, QuantLib parity, engine pin, layout
docs/RELEASING.md: how a release is cut
User guide on the site: https://quantra.io/docs/app/agents
Development
uv run pytest && uv run ruff check . && uv run ruff format --check . && uv run mypy src # the gate
QUANTRA_ENGINE_URL=http://localhost:18087 uv run python scripts/live_check.py # every tool vs a real engineThe engine contract is pinned to the tag in src/quantra_mcp/schema/PIN
(v0.14.0); the QuantLib version that engine is built on is in schema/QUANTLIB_PIN
(1.41). scripts/fetch_sources.py fetches both source trees (text files only, verified
against schema/SOURCES.lock) into vendor/sources/ for the search_source /
read_source / list_source tools; the container image ships them. Requests are unchanged since 0.7.0; responses follow the pinned 0.8.x contract (swaption greek units, theta, zero-valued fields present). Bump it with
scripts/pin_engine.py, never by hand (docs/development.md).
License
BSD-3-Clause. See LICENSE.
The server vendors, for the source-reading tools and the examples, two BSD-3-Clause
code bases: the Quantra pricing engine (https://github.com/joseprupi/quantraserver,
LICENSE.txt) and QuantLib (https://github.com/lballabio/QuantLib, LICENSE.TXT,
copyright the QuantLib Group and contributors). Their licence files are served verbatim
at the roots of the fetched trees (read_source("engine", "LICENSE.txt"),
read_source("quantlib", "LICENSE.TXT")).
Available Tools
47 toolsbootstrap_curveA
Bootstrap curves on the engine and sample them (POST /bootstrap-curves).
Args:
curves: items are TermStructure objects, build_curve results
({curve, indices}) or {"session": "<name>"} references
to a stored curve or market.
as_of: YYYY-MM-DD valuation date (pricing.as_of_date).
queries: CurveQuerySpec objects or build_query results.
indices: extra IndexDef objects or {"session": name} refs;
indices carried by build_curve results are added automatically.
Identical duplicates are sent once; conflicting ids are rejected.
calendar_overrides: per-request holiday corrections (engine >= 0.7.0).
request_id: optional X-Request-Id.
The echoed request is the fully RESOLVED body. summary lists per
curve {id, pillars, first_grid_date, last_grid_date, measures}; the
sampled values are in response.results[].series.
Inputs: as_of (required), curves (required), queries (required), indices, +2 more. Returns: object
bootstrap_inflation_curveB
POST /bootstrap-inflation-curves with a raw request body (validated first).
Args:
body: the engine's BootstrapInflationCurvesRequest (see
engine_schema('/bootstrap-inflation-curves')); no preset
support yet, the body is sent as given once it validates.
request_id: optional X-Request-Id.
Inputs: body (required), request_id. Returns: object
build_curveA
Turn a quote strip into an engine curve spec (no engine call).
Args:
id: curve id to register, e.g. USD_SOFR_OIS.
preset: a preset id from list_presets; supplies the index
definition and every helper convention.
quotes: [{type: deposit|fra|future|swap|ois, tenor: "6M", rate: 0.052}, ...]
(fra: months_to_start/months_to_end; future:
future_start_date + price or rate). Sorted by
maturity; a duplicate (type, tenor) is rejected locally.
reference_date: YYYY-MM-DD curve date (normally the pricing as_of).
market_data_source: where the market numbers in this call come from. user_pasted
(the user pasted or typed the numbers in this conversation), user_file (the
user attached a file/screenshot the numbers were read from), engine_example
(an engine example's pricing block, only when the user explicitly asked to run
an example), session (a market previously stored in this session, which
itself came from one of the above). There is no value for estimated, recalled or
placeholder data. If you would have to invent numbers, do not call this tool:
ask the user for the data.
trait: override the preset's bootstrap trait (Discount,
ZeroRate, FwdRate).
interpolator: override the preset's interpolator.
day_counter: override the preset's curve day counter.
Returns {ok, curve, indices, preset, notes}: curve is the
TermStructure and indices the IndexDef list to pass to
bootstrap_curve (or to session_put); notes lists every
default applied with its source. Nothing is priced here.
Inputs: id (required), preset (required), quotes (required), reference_date (required), +4 more. Returns: object
build_queryA
A CurveQuerySpec for bootstrap_curve (no engine call).
Args:
curve_id: the curve to sample.
measures: any of DF, ZERO, FWD.
tenors: TenorGrid, e.g. ["1M", "6M", "1Y", "5Y", "10Y"]; needs
calendar + business_day_convention to roll each tenor.
range_grid: RangeGrid alternative {end_date, step_number, step_time_unit, start_date?, business_days_only?, calendar?, ...}.
zero: options for ZERO (default: continuous, annual, curve day counter).
fwd: required when FWD is requested (forward_type Period + tenor,
or Instantaneous + eps; compounding; frequency).
Returns {ok, query, notes}.
Inputs: curve_id (required), measures (required), fwd, zero, +4 more. Returns: object
build_value_curveA
An interpolated curve from explicit values (no engine call).
Args:
id: curve id.
kind: zero (InterpolatedZero), discount (InterpolatedDiscount:
first point must be the reference date with value 1.0) or
forward (InterpolatedFwd: instantaneous continuously-compounded
forwards; Linear/BackwardFlat/ForwardFlat only).
points: [{date: "2026-01-15", value: 0.96}, {tenor: "2Y", value: ...}]
in order; the engine anchors the curve at the first point.
reference_date: YYYY-MM-DD.
market_data_source: where the market numbers in this call come from. user_pasted
(the user pasted or typed the numbers in this conversation), user_file (the
user attached a file/screenshot the numbers were read from), engine_example
(an engine example's pricing block, only when the user explicitly asked to run
an example), session (a market previously stored in this session, which
itself came from one of the above). There is no value for estimated, recalled or
placeholder data. If you would have to invent numbers, do not call this tool:
ask the user for the data.
preset: take the curve day counter and point calendar/convention
from this preset; or give conventions explicitly.
conventions: {day_counter, calendar, business_day_convention}.
compounding, frequency: zero points only (default Continuous /
Annual; all points share them).
interpolator: default Linear (zero, forward) or LogLinear (discount).
Returns {ok, curve, indices: [], preset, notes}.
Inputs: id (required), kind (required), points (required), reference_date (required), +6 more. Returns: object
calendar_advanceA
Advance a date by a tenor on a QuantLib calendar (POST /calendar-advance).
Args:
calendar: engine Calendar enum value.
date: YYYY-MM-DD start date.
tenor_number: number of units; negative shifts backwards.
tenor_unit: engine TimeUnit (Days, Weeks, Months, Years, ...).
convention: engine BusinessDayConvention (Following,
ModifiedFollowing, Preceding, Unadjusted, ...).
end_of_month: apply the end-of-month rule (default False).
calendar_overrides: optional per-request holiday corrections.
summary = {input_date, advanced_date} taken from the engine's response.
Inputs: date (required), calendar (required), convention (required), tenor_unit (required), +3 more. Returns: object
calendar_business_daysA
Business days of a QuantLib calendar between two dates (POST /calendar-business-days).
Args:
calendar: engine Calendar enum value.
start_date: YYYY-MM-DD.
end_date: YYYY-MM-DD.
include_start: whether start_date itself may be listed (default True).
include_end: whether end_date itself may be listed (default True).
calendar_overrides: optional per-request holiday corrections.
summary = {count, first, last} taken from the engine's response.
Inputs: calendar (required), end_date (required), start_date (required), include_end, +2 more. Returns: object
calendar_holidaysA
Holidays of a QuantLib calendar between two dates (POST /calendar-holidays).
Args:
calendar: engine Calendar enum value, e.g. TARGET, UnitedStates.
start_date: YYYY-MM-DD (inclusive).
end_date: YYYY-MM-DD (inclusive).
include_weekends: also list Saturdays/Sundays (default False).
calendar_overrides: optional per-request holiday corrections
(added_holidays / removed_holidays per calendar).
summary = {count, first, last} taken from the engine's response.
Inputs: calendar (required), end_date (required), start_date (required), include_weekends, +1 more. Returns: object
calibrate_swaption_modelC
Calibrate a Hull-White model to swaption vols (POST /calibrate-swaption-model)
from a raw CalibrateSwaptionModelRequest body (pricing with a
SwaptionModelSpec in Calibrate mode and its hw_calibration block,
model_id). Validated, then forwarded; see the hwcal_* examples.
summary: hw_a, hw_sigma, rmse, num_helpers.
Inputs: body (required), request_id. Returns: object
calibrate_swaption_volB
Calibrate a SABR swaption cube (POST /calibrate-swaption-vol) from a raw
CalibrateSwaptionVolRequest body (pricing with a SwaptionSabrCalibrateSpec
surface, vol_id, discounting_curve_id, forwarding_curve_id). Validated
against the vendored spec, then forwarded; see the vol examples
(sabrcal_*) for complete bodies. summary selects the calibration block.
Inputs: body (required), request_id. Returns: object
compare_resultsA
Put the user's numbers next to the engine's (no engine call, no modelling).
Args:
external: {label: number} as the user quoted them, e.g.
{"NPV": 10359.49, "DV01": 415.5, "fair rate": 0.0337}. Labels are
matched case- and punctuation-insensitively to response fields
(npv / premium / PV -> npv; DV01 / PV01 -> dv01;
fair rate -> fair_rate then atm_forward; vol ->
implied_volatility, ...). Give the external numbers in the engine's
units (currency amounts; rates and vols as decimals).
quantra: a pricing tool result (its response is used) or the engine
response object itself. The first priced item is compared.
Returns rows = [{label, mapped_to, quantra_path, external, quantra, abs_diff, rel_diff, topic, topic_uri}] with abs_diff = quantra - external
and rel_diff = abs_diff / |external|; unmapped for labels with no field;
mapping shows the candidates tried. topic is the methodology page
(explain_method) to consult for that metric.
Inputs: quantra (required), external (required). Returns: object
curve_from_pasted_tableA
A curve from a table the user pasted (a vendor curve screen, a spreadsheet, a ticket): parses it and calls build_value_curve (discount / zero) or build_curve (par quotes). No engine call; no arithmetic on the values.
Args:
text: the pasted rows. CSV / TSV / ';' / '|' / whitespace separated, header
optional. Each row: a date (2034-09-18, 18-Sep-2034,
09/18/2034 with date_format) or a tenor (10Y), then the
value. % values are divided by 100; 1,000.5 loses its commas.
An optional word per row (ois, swap, deposit) tags a par
quote's type.
id: curve id to register.
kind: discount (discount factors -> InterpolatedDiscount), zero
(zero rates -> InterpolatedZero) or par (market quotes -> bootstrap
helpers of the preset).
market_data_source: where the market numbers in this call come from. user_pasted
(the user pasted or typed the numbers in this conversation), user_file (the
user attached a file/screenshot the numbers were read from), engine_example
(an engine example's pricing block, only when the user explicitly asked to run
an example), session (a market previously stored in this session, which
itself came from one of the above). There is no value for estimated, recalled or
placeholder data. If you would have to invent numbers, do not call this tool:
ask the user for the data.
preset: supplies the curve day counter and point calendar/convention
(USD_SOFR_OIS...); required for par; or give conventions.
reference_date: the curve / as-of date. For discount it may be omitted
when the first row is that date with value 1.0.
quote_type: par tables only: the helper type when the rows do not name one
and the preset offers several.
percent: true = every value is a percentage; default: only values
written with %.
date_format: mdy / dmy for slash dates; inferred when a field exceeds
12, otherwise required.
compounding, frequency: zero tables only (default Continuous / Annual).
interpolator: override the builder default.
Returns the builder result ({ok, curve, indices, preset, notes}) plus
parsed_rows (line, label, value as read), unparsed (line, text,
reason) and header. For a discount table whose first row is not the
reference date, the anchor point {reference_date: 1.0} the engine
requires is added in front and said so in notes.
Inputs: id (required), kind (required), text (required), market_data_source (required), +9 more. Returns: object
engine_requestA
POST a JSON body to any engine endpoint (the raw escape hatch).
Args:
endpoint: one of the engine's POST paths (see list_endpoints),
e.g. /price-ois-swap.
body: the full request object exactly as the engine expects it
(engine_schema and the quantra://examples/* resources
show the shape). The engine does not default omitted fields.
validate: check body against the vendored OpenAPI schema first
(default True). On failure nothing is sent and problems
lists each JSON-pointer path with a message.
request_id: optional X-Request-Id to forward; one is generated
when absent and reported in engine.request_id.
Returns {ok, endpoint, request, response, engine}; on an engine
error ok=false with the HTTP status and the engine's error
text verbatim (400 = request wrong, 422 = well-formed but unpriceable).
Inputs: body (required), endpoint (required), validate, request_id. Returns: object
engine_schemaA
Request and response JSON schema for one engine endpoint.
Args:
endpoint: one of the 24 POST paths, e.g. /price-ois-swap
(leading slash optional). Unknown names return an error that
lists the valid endpoints.
depth: how many levels of $ref to inline (0..8, default 3).
Deeper refs are left as {"$ref": "<Name>", "unresolved": true}.
Returns the spec's top-level required list, the top-level field
names, and both schemas. Remember the engine's rule: a field the
product needs that is omitted is an error, never a default.
Inputs: endpoint (required), depth. Returns: object
explain_methodA
How the engine computes something, cited to its own docs and source at the pinned tag; or how this server derives its analytics (no engine call).
Args:
topic: one of npv, fair-rate, greeks-bump-and-reprice, theta,
curve-bootstrap, value-curves, settlement-and-cash-settlement,
volatility-types, calendars-and-overrides,
day-counters-and-compounding, schedules-and-stubs, error-codes
(engine pages), or connector-analytics (what swap_dv01, key_rate_ladder,
scenario, fair_rate and reprice_with compute on top of engine outputs, cited
into this server's own source).
Returns the page as markdown (plain-language summary, the cited excerpts each
with a path@tag:Lstart-Lend citation and a GitHub permalink, the request
fields that control the behaviour, and what is NOT documented), plus
citations, links (the permalinks), repository and not_documented
as lists; repos gives the engine and connector repository URLs. Quote the
citations (or hand over the links) when you explain a number; never assert a
cause the page does not support.
Inputs: topic (required). Returns: object
fair_rateA
The engine's fair (par) rate of a swap, read from the pricing response.
Args:
market, trade, as_of: as in swap_dv01.
market_data_source: where the market numbers in this call come from. user_pasted
(the user pasted or typed the numbers in this conversation), user_file (the
user attached a file/screenshot the numbers were read from), engine_example
(an engine example's pricing block, only when the user explicitly asked to run
an example), session (a market previously stored in this session, which
itself came from one of the above). There is no value for estimated, recalled or
placeholder data. If you would have to invent numbers, do not call this tool:
ask the user for the data.
Result: fair_rate / fair_spread exactly as the engine returned them (plus
npv); when the response carries neither, provided_by_engine is false and
message says so (nothing is solved locally). calls[0] is the pricing.
Inputs: trade (required), market (required), market_data_source (required), as_of, +2 more. Returns: object
get_exampleA
One vendored example: endpoint, catalog description, reference value and the
complete request body (no engine call).
Use it as engine_request(endpoint, body); or pass body["pricing"] as the
market of a pricing tool and let the tool rebuild the trade from a preset.
Inputs: name (required). Returns: object
get_presetB
One preset as data: index definition, curve settings, every helper convention block and the provenance of each field.
Args:
id: e.g. USD_SOFR_OIS, EUR_ESTR_OIS, GBP_SONIA_OIS,
GBP_SONIA_SWAP, EUR_EURIBOR_6M, EUR_EURIBOR_3M.
Inputs: id (required). Returns: object
key_rate_ladderA
Key-rate DV01 ladder: one bump per pillar of a curve, plus a parallel bump.
Args:
market, trade, bump_bp, method, as_of: as in swap_dv01.
market_data_source: where the market numbers in this call come from. user_pasted
(the user pasted or typed the numbers in this conversation), user_file (the
user attached a file/screenshot the numbers were read from), engine_example
(an engine example's pricing block, only when the user explicitly asked to run
an example), session (a market previously stored in this session, which
itself came from one of the above). There is no value for estimated, recalled or
placeholder data. If you would have to invent numbers, do not call this tool:
ask the user for the data.
curve: id of the curve whose pillars are the buckets (default: the trade's
discounting curve). Buckets are that curve's ACTUAL points in wire order.
Result: ladder = ordered [{pillar, quote_from, quote_up / quote_down, npv_up / npv_down, dv01}], parallel (all pillars bumped together),
sum_of_buckets (sum of the ladder dv01s), definitions (the exact difference
per method) and calls = base + parallel + one complete pricing result per pillar
and side (centered: 1 + 2 + 2 x pillars calls). Reprices run concurrently, bounded by
QUANTRA_MAX_CONCURRENCY.
Inputs: trade (required), market (required), market_data_source (required), as_of, +5 more. Returns: object
list_endpointsA
The engine's POST endpoints (24 at the pinned version) with one-line descriptions.
Taken from the vendored OpenAPI spec, not from the live engine; compare
with quantra_meta to detect a version mismatch.
Inputs: no named parameters. Returns: object
list_enumsA
Values of an engine enum from the vendored spec.
Args:
name: e.g. Calendar, DayCounter, Frequency,
BusinessDayConvention, TimeUnit, Compounding,
Interpolator, BootstrapTrait. An unknown name returns
an error listing every available enum.
Inputs: name (required). Returns: object
list_examplesA
List the vendored engine example requests (no engine call).
Args:
category: one of the fixture folders (ir_swaps, bonds, swaption,
cds, fra, cap_floor, equity, inflation,
inflation_cap_floor, curves, calendar, vol,
callable_bonds, zero_coupon_swap, misc, blog).
product: filter by endpoint product instead (vanilla_swap, ois_swap,
fixed_rate_bond, swaption, cds, equity_option, ...).
Each row: name, category, endpoint, product, title,
reference_text (the QuantLib value the engine is asserted to match, when
cataloged) and the resource uri. get_example(name) returns the body.
Inputs: product, category. Returns: object
list_presetsA
Market-convention presets available to build_curve / build_value_curve.
Each row: id, currency, index (the engine index id the
preset registers), helpers (quote types it supports: deposit, fra,
future, swap, ois), curve (day counter / interpolator / trait) and
the provenance of the conventions. get_preset returns the data.
Inputs: no named parameters. Returns: object
price_callable_fixed_rate_bondA
Price a callable / puttable fixed-rate bond on a Hull-White lattice (POST /price-callable-fixed-rate-bond).
Args:
market_data_source: where the market numbers in this call come from. user_pasted
(the user pasted or typed the numbers in this conversation), user_file (the
user attached a file/screenshot the numbers were read from), engine_example
(an engine example's pricing block, only when the user explicitly asked to run
an example), session (a market previously stored in this session, which
itself came from one of the above). There is no value for estimated, recalled or
placeholder data. If you would have to invent numbers, do not call this tool:
ask the user for the data.
preset: a preset with a callable_fixed_rate_bond block (EUR_FIXED_BOND).
call_schedule: [{date, price, type: Call|Put}] with increasing dates
(clean price per 100 of face).
model: {a, sigma, lattice_steps?, id?} (explicit Hull-White, lattice_steps
default from the preset) or the id of a SwaptionModelSpec in the market.
tree_steps: engine lattice steps for the bond (default from the preset).
Other arguments: as in price_fixed_rate_bond.
Inputs: model (required), market (required), preset (required), issue_date (required), +14 more. Returns: object
price_cap_floorA
Price an interest-rate cap, floor or collar (POST /price-cap-floor).
Args:
market_data_source: where the market numbers in this call come from. user_pasted
(the user pasted or typed the numbers in this conversation), user_file (the
user attached a file/screenshot the numbers were read from), engine_example
(an engine example's pricing block, only when the user explicitly asked to run
an example), session (a market previously stored in this session, which
itself came from one of the above). There is no value for estimated, recalled or
placeholder data. If you would have to invent numbers, do not call this tool:
ask the user for the data.
preset: a preset with a cap_floor block (EUR_EURIBOR_3M quarterly,
EUR_EURIBOR_6M semiannual).
cap_floor_type: Cap | Floor | Collar. strike: decimal.
effective_date, termination_date | tenor: as in price_vanilla_swap.
vol: {constant: 0.2, type: Lognormal|Normal|ShiftedLognormal, displacement?, id?} (an OptionletVolSpec the tool adds to the market, base conventions
from the preset) or the id of a surface already in the market.
model: Black | Bachelier | ShiftedBlack | HullWhiteLattice (a
CapFloorModelSpec the tool adds, id <type>_model) or a model id.
include_details: per-caplet breakdown.
frequency, day_counter, business_day_convention, schedule_overrides:
default from the preset (noted).
summary.cap_floors: npv, atm_rate, implied_volatility.
Inputs: vol (required), model (required), market (required), preset (required), +19 more. Returns: object
price_cdsA
Price a single-name CDS (POST /price-cds).
Args:
market_data_source: where the market numbers in this call come from. user_pasted
(the user pasted or typed the numbers in this conversation), user_file (the
user attached a file/screenshot the numbers were read from), engine_example
(an engine example's pricing block, only when the user explicitly asked to run
an example), session (a market previously stored in this session, which
itself came from one of the above). There is no value for estimated, recalled or
placeholder data. If you would have to invent numbers, do not call this tool:
ask the user for the data.
side: Buyer (buy protection) or Seller. notional: > 0.
running_coupon: decimal (0.01 = 100bp).
credit_curve: {par_spreads: [{tenor, spread}], recovery_rate?, id?}
(bootstrapped by the engine with the preset's helper conventions),
{hazard_rate, recovery_rate?, id?} (flat) or a credit curve id in
the market.
preset: a preset with a cds block (default EUR_CDS: quarterly
TwentiethIMM, Following, Actual360, MidPoint).
start: effective date YYYY-MM-DD or as_of (default).
maturity: YYYY-MM-DD; or tenor (engine-resolved, Unadjusted).
recovery_rate: for a curve the tool builds (default: preset, 0.4).
model: MidPoint | ISDA (CdsModelSpec added, id cds_<type>) or a
model id in the market.
upfront / upfront_date, protection_start (default = start), trade_date
(default = as_of), frequency, day_counter, business_day_convention,
cash_settlement_days, schedule_overrides: optional; defaults noted.
summary.cds_list: npv, fair_spread, fair_upfront, leg npvs.
Inputs: side (required), market (required), notional (required), credit_curve (required), +22 more. Returns: object
price_equity_optionA
Price a vanilla equity option (POST /price-equity-option).
Args:
market_data_source: where the market numbers in this call come from. user_pasted
(the user pasted or typed the numbers in this conversation), user_file (the
user attached a file/screenshot the numbers were read from), engine_example
(an engine example's pricing block, only when the user explicitly asked to run
an example), session (a market previously stored in this session, which
itself came from one of the above). There is no value for estimated, recalled or
placeholder data. If you would have to invent numbers, do not call this tool:
ask the user for the data.
spot: spot price (a Price quote the tool adds) or a quote id in the market.
strike, expiry (YYYY-MM-DD), option_type Call | Put.
vol: {constant: 0.2, id?} (constant BlackVolSpec added) or a surface id.
rate_curve: {rate, end_date, id?} (flat continuous zero curve from as_of to
end_date, added) or a curve id in the market.
dividend_yield: same shape ({rate: 0.0, end_date} for no dividends); the
engine requires a dividend curve id on every underlying.
preset: a preset with an equity_option block (default EUR_EQUITY).
exercise: European | American (window exercise_start..expiry;
start default = as_of) | Bermudan (exercise_dates, last = expiry).
model: {type: BlackScholesAnalytic|BinomialCRR, binomial_steps?, id?} or a
model id; default BlackScholesAnalytic (id bs_analytic).
discrete_dividends: [{ex_date, amount}] cash dividends on the underlying.
market: optional; a pricing block / market with curves, quotes or
surfaces to reference by id. as_of is required without it.
summary.options: npv, delta, gamma, vega, theta, rho.
Inputs: vol (required), spot (required), expiry (required), strike (required), +18 more. Returns: object
price_fixed_rate_bondA
Price a fixed-rate bond (POST /price-fixed-rate-bond).
Args:
market_data_source: where the market numbers in this call come from. user_pasted
(the user pasted or typed the numbers in this conversation), user_file (the
user attached a file/screenshot the numbers were read from), engine_example
(an engine example's pricing block, only when the user explicitly asked to run
an example), session (a market previously stored in this session, which
itself came from one of the above). There is no value for estimated, recalled or
placeholder data. If you would have to invent numbers, do not call this tool:
ask the user for the data.
market: as in price_vanilla_swap.
preset: a preset with a fixed_rate_bond block (EUR_FIXED_BOND).
face_amount: > 0. coupon_rate: annual decimal coupon.
issue_date: YYYY-MM-DD or spot (as_of + preset settlement days).
maturity_date: YYYY-MM-DD, or tenor (engine-resolved from the
effective date, Unadjusted).
effective_date: first accrual date (default: = issue_date).
discounting_curve: curve id in the market.
overrides: settlement_days, frequency, accrual_day_counter,
payment_convention, redemption, notionals, schedule rules.
yield_overrides: how the yield is quoted (day_counter/compounding/frequency).
include_details / include_flows: pricing.options.bond_pricing_details / _flows.
summary.bonds: npv, clean/dirty price, accrued, yield, durations.
Inputs: market (required), preset (required), issue_date (required), coupon_rate (required), +14 more. Returns: object
price_floating_rate_bondA
Price a floating-rate note (POST /price-floating-rate-bond).
Args:
market_data_source: where the market numbers in this call come from. user_pasted
(the user pasted or typed the numbers in this conversation), user_file (the
user attached a file/screenshot the numbers were read from), engine_example
(an engine example's pricing block, only when the user explicitly asked to run
an example), session (a market previously stored in this session, which
itself came from one of the above). There is no value for estimated, recalled or
placeholder data. If you would have to invent numbers, do not call this tool:
ask the user for the data.
preset: a preset with a floating_rate_bond block (EUR_EURIBOR_6M).
face_amount, issue_date, maturity_date | tenor, effective_date, overrides,
include_details, include_flows: as in price_fixed_rate_bond.
spread: coupon spread over the index (decimal). index_id: default preset's.
fixing_days, in_arrears: default from the preset (noted).
coupon_pricer: id of a coupon pricer in the market; when omitted the tool
adds the preset's zero-vol BlackIborCouponPricer (an Ibor coupon needs one).
Inputs: market (required), preset (required), issue_date (required), face_amount (required), +18 more. Returns: object
price_fraA
Price a forward rate agreement (POST /price-fra).
Args:
market_data_source: where the market numbers in this call come from. user_pasted
(the user pasted or typed the numbers in this conversation), user_file (the
user attached a file/screenshot the numbers were read from), engine_example
(an engine example's pricing block, only when the user explicitly asked to run
an example), session (a market previously stored in this session, which
itself came from one of the above). There is no value for estimated, recalled or
placeholder data. If you would have to invent numbers, do not call this tool:
ask the user for the data.
preset: a preset with a fra block (EUR_EURIBOR_3M, EUR_EURIBOR_6M).
notional: > 0. strike: agreed forward rate (decimal).
side: Long (pay fixed) or Short.
months_to_start, months_to_end: e.g. 3, 6 for a 3x6; the engine resolves
spot = as_of + settlement days, then spot + 3M / 6M with the preset's
calendar and convention (three /calendar-advance calls, all echoed).
start_date, maturity_date: explicit alternative to the months.
index_id, day_counter, business_day_convention: default from the preset.
summary.fras: npv, forward_rate, spot_value, settlement_date.
Inputs: side (required), market (required), preset (required), strike (required), +15 more. Returns: object
price_ois_swapA
Price an OIS (fixed vs compounded overnight) swap (POST /price-ois-swap).
Args:
market_data_source: where the market numbers in this call come from. user_pasted
(the user pasted or typed the numbers in this conversation), user_file (the
user attached a file/screenshot the numbers were read from), engine_example
(an engine example's pricing block, only when the user explicitly asked to run
an example), session (a market previously stored in this session, which
itself came from one of the above). There is no value for estimated, recalled or
placeholder data. If you would have to invent numbers, do not call this tool:
ask the user for the data.
market: as in price_vanilla_swap.
preset: a preset with an ois_swap block (USD_SOFR_OIS: payment lag 2;
EUR_ESTR_OIS: payment lag 0).
swap_type, notional, fixed_rate, effective_date, termination_date | tenor,
spread, index_id, discounting_curve, forwarding_curve: as in
price_vanilla_swap (the overnight index id defaults to the preset's).
payment_lag, averaging_method, lookback_days, lockout_days,
apply_observation_shift, telescopic_value_dates: overnight-leg
parameters; each defaults to the preset's value (noted).
fixed_leg_overrides, overnight_leg_overrides, additional_trades, as_of,
include_flows: as in price_vanilla_swap.
Inputs: market (required), preset (required), notional (required), swap_type (required), +22 more. Returns: object
price_swaptionA
Price a swaption (POST /price-swaption).
Args:
market_data_source: where the market numbers in this call come from. user_pasted
(the user pasted or typed the numbers in this conversation), user_file (the
user attached a file/screenshot the numbers were read from), engine_example
(an engine example's pricing block, only when the user explicitly asked to run
an example), session (a market previously stored in this session, which
itself came from one of the above). There is no value for estimated, recalled or
placeholder data. If you would have to invent numbers, do not call this tool:
ask the user for the data.
preset: a preset with swaption + vanilla_swap blocks (EUR_EURIBOR_6M).
underlying: the swap exercised into, as a VanillaSwapTrade (swap_type,
notional, fixed_rate, effective_date, termination_date | tenor, ...).
effective_date: "spot" = exercise_date + preset settlement days
(engine-resolved). For an OIS underlying set underlying_type OisSwap.
exercise_date: European / American. exercise_dates: Bermudan.
settlement_type: Physical (method default from the preset, PhysicalOTC) or
Cash (give settlement_method: CollateralizedCashPrice | ParYieldCurve).
vol: {constant, type, displacement?, id?}, {expiries, tenors, vols, type, id?} (ATM matrix), {payload_type, payload, id?} (SmileCube /
SabrParams / SabrCalibrate given raw) or a surface id in the market. Built
surfaces are SwaptionVolSpec with the preset's swap_index_id.
model: Black | ShiftedBlack | Bachelier (SwaptionModelSpec added,
id <type>_model), {a, sigma, lattice_steps, id?} (HullWhiteLattice
explicit) or a model id in the market.
include_details: pricing.options.swaption_pricing_details (delta/vega/...).
include_diagnostics: per-SABR-surface diagnostics in the response.
summary.swaptions: npv, implied_volatility, atm_forward, annuity.
Inputs: vol (required), model (required), market (required), preset (required), +16 more. Returns: object
price_vanilla_swapA
Price a fixed-vs-IBOR swap (POST /price-vanilla-swap).
Args:
market_data_source: where the market numbers in this call come from. user_pasted
(the user pasted or typed the numbers in this conversation), user_file (the
user attached a file/screenshot the numbers were read from), engine_example
(an engine example's pricing block, only when the user explicitly asked to run
an example), session (a market previously stored in this session, which
itself came from one of the above). There is no value for estimated, recalled or
placeholder data. If you would have to invent numbers, do not call this tool:
ask the user for the data.
market: {"session": name}, an engine pricing block (used verbatim)
or {curves: [...], indices: [...]} (build_curve results allowed).
preset: a preset with a vanilla_swap block (EUR_EURIBOR_6M,
EUR_EURIBOR_3M): schedule, fixed and floating leg conventions.
swap_type: Payer (pay fixed) or Receiver.
notional: constant notional (> 0).
fixed_rate: decimal, e.g. 0.032.
effective_date: YYYY-MM-DD or spot (as_of + the preset's settlement
days, resolved by the engine's /calendar-advance).
discounting_curve, forwarding_curve: curve ids in the market.
termination_date: YYYY-MM-DD; or give tenor (5Y, resolved by the
engine from the effective date, Unadjusted).
spread: floating-leg spread (decimal, default 0.0).
index_id: floating index id in the market (default: the preset's index id).
fixed_leg_overrides, floating_leg_overrides: replace conventions
(frequency, day_counter, payment_convention, notionals, schedule rules).
additional_trades: more swaps for the same request (same preset/market).
as_of: YYYY-MM-DD; required unless market is a pricing block.
include_flows: ask the engine for per-leg cash flows.
Result: uniform shape + notes (every convention with its source),
date_resolution (the /calendar-advance calls) and summary.swaps
(npv, fair_rate, leg npvs selected from the response).
Inputs: market (required), preset (required), notional (required), swap_type (required), +16 more. Returns: object
price_yoy_inflation_cap_floorA
Price a year-on-year inflation cap / floor / collar (POST /price-year-on-year-inflation-cap-floor).
fixings REQUIRED as in price_yoy_inflation_swap. vol:
{constant: 0.01, type: Black|Bachelier|UnitDisplacedBlack, id?} (a
YoYOptionletVolSpec the tool adds with the preset's conventions) or a surface
id. cap_rate for Cap/Collar, floor_rate for Floor/Collar.
Args:
market_data_source: where the market numbers in this call come from. user_pasted
(the user pasted or typed the numbers in this conversation), user_file (the
user attached a file/screenshot the numbers were read from), engine_example
(an engine example's pricing block, only when the user explicitly asked to run
an example), session (a market previously stored in this session, which
itself came from one of the above). There is no value for estimated, recalled or
placeholder data. If you would have to invent numbers, do not call this tool:
ask the user for the data.
Inputs: vol (required), market (required), fixings (required), notional (required), +19 more. Returns: object
price_yoy_inflation_swapB
Price a year-on-year inflation swap (POST /price-year-on-year-inflation-swap).
The market must carry the YoY inflation index and a YoYInflation curve.
fixings (YoY rates) is REQUIRED for the same reason as in
price_zc_inflation_swap. Fixed and YoY legs share the preset's schedule
(annual by default); spread is added to the YoY rate.
Args:
market_data_source: where the market numbers in this call come from. user_pasted
(the user pasted or typed the numbers in this conversation), user_file (the
user attached a file/screenshot the numbers were read from), engine_example
(an engine example's pricing block, only when the user explicitly asked to run
an example), session (a market previously stored in this session, which
itself came from one of the above). There is no value for estimated, recalled or
placeholder data. If you would have to invent numbers, do not call this tool:
ask the user for the data.
Inputs: market (required), fixings (required), notional (required), swap_type (required), +17 more. Returns: object
price_zc_inflation_swapA
Price a zero-coupon inflation swap (POST /price-zero-coupon-inflation-swap).
The market must carry the inflation index and a ZeroInflation curve
(pricing.inflation; see the inflation examples). fixings is
REQUIRED: the engine needs the CPI fixing at start minus the observation lag
(and the curve helpers need the recent history) and this server has no
market-data source; the tool sets them on the index and says so in notes.
Args:
market_data_source: where the market numbers in this call come from. user_pasted
(the user pasted or typed the numbers in this conversation), user_file (the
user attached a file/screenshot the numbers were read from), engine_example
(an engine example's pricing block, only when the user explicitly asked to run
an example), session (a market previously stored in this session, which
itself came from one of the above). There is no value for estimated, recalled or
placeholder data. If you would have to invent numbers, do not call this tool:
ask the user for the data.
inflation_index_id: id in pricing.inflation.inflation_indices.
fixings: [{date: "2024-12-01", value: 126.16}, ...] monthly CPI levels.
swap_type: Payer pays fixed. notional, fixed_rate: decimal.
start_date: YYYY-MM-DD or as_of. maturity_date | tenor.
preset: a preset with a zc_inflation_swap block (default EUR_HICP).
Inputs: market (required), fixings (required), notional (required), swap_type (required), +14 more. Returns: object
price_zero_coupon_bondA
Price a zero-coupon bond (POST /price-zero-coupon-bond).
Args:
market_data_source: where the market numbers in this call come from. user_pasted
(the user pasted or typed the numbers in this conversation), user_file (the
user attached a file/screenshot the numbers were read from), engine_example
(an engine example's pricing block, only when the user explicitly asked to run
an example), session (a market previously stored in this session, which
itself came from one of the above). There is no value for estimated, recalled or
placeholder data. If you would have to invent numbers, do not call this tool:
ask the user for the data.
preset: a preset with a zero_coupon_bond block (EUR_FIXED_BOND,
settlement T+3 on TARGET).
maturity_date: YYYY-MM-DD, or tenor counted (by the engine, Unadjusted)
from issue_date when given else from as_of.
issue_date: YYYY-MM-DD, as_of or omitted (engine: null date).
settlement_days, redemption: default from the preset (noted).
include_details: pricing.options.bond_pricing_details (duration, convexity).
Inputs: market (required), preset (required), face_amount (required), discounting_curve (required), +12 more. Returns: object
quantra_healthA
Engine liveness, verbatim from GET /health.
Inputs: no named parameters. Returns: object
quantra_metaA
Engine metadata, verbatim from GET /meta.
Call this first: it tells you the engine's API version, QuantLib
version, product list and endpoint list. The response field is the
engine body unchanged.
Inputs: no named parameters. Returns: object
reprice_withA
Test a hypothesis: change one or more request fields and reprice.
Args:
result_or_request: a previous pricing tool result (its endpoint and echoed
request are used; its response is the base unless
reprice_base), or an explicit {"endpoint": "/price-swaption", "body": {...}}.
market_data_source: where the market numbers in the request come from. A previous
tool result carries its own declaration and it is reused (the argument may be
omitted or must agree); for an explicit {endpoint, body} or a result without
one it is required: user_pasted (the user pasted or typed the numbers in
this conversation), user_file (the user attached a file/screenshot the
numbers were read from), engine_example (an engine example's pricing block,
only when the user explicitly asked to run an example), session (a market
previously stored in this session, which itself came from one of the above).
There is no value for estimated, recalled or placeholder data. If you would have
to invent numbers, do not call this tool: ask the user for the data.
changes: [{path, value}] or [{path, bump_bp}]; path is dotted /
indexed into the request body (swaptions[0].swaption.settlement_method,
pricing.rates.curves[0].points[2].point.rate, pricing.as_of_date,
pricing.rates.curves[0].interpolator). bump_bp adds
bump_bp / 10000 to a numeric field.
reprice_base: also reprice the unchanged request now (default: reuse the
given result's response).
validate: check the changed body against the vendored schema before sending.
Returns changes_applied (before / after per change), request_diff (every
leaf that differs between the two requests), base and changed (complete
uniform results, each replayable from its request) and differences: the
numeric top-level fields of the first priced item with difference = changed - base. Nothing else is computed. The engine's error, if any, is verbatim.
Inputs: changes (required), result_or_request (required), validate, request_id, +2 more. Returns: object
sample_vol_surfaceB
Sample volatility surfaces on a grid (POST /sample-vol-surfaces) from a raw
SampleVolSurfacesRequest body (pricing with the surfaces, queries).
Validated, then forwarded; see the volsample_* examples. summary: per
result vol_id, vol type, grid sizes.
Inputs: body (required), request_id. Returns: object
scenarioA
Reprice a swap under named market variants and tabulate NPV vs base.
Args:
market, trade, as_of: as in swap_dv01.
market_data_source: where the market numbers in this call come from. user_pasted
(the user pasted or typed the numbers in this conversation), user_file (the
user attached a file/screenshot the numbers were read from), engine_example
(an engine example's pricing block, only when the user explicitly asked to run
an example), session (a market previously stored in this session, which
itself came from one of the above). There is no value for estimated, recalled or
placeholder data. If you would have to invent numbers, do not call this tool:
ask the user for the data.
scenarios: [{name, bumps: [{curve, bp, pillar?}], replace_quotes: [{curve, pillar, value}]}]. A bump without pillar moves every pillar
of that curve; pillar is a label ("5Y", "3x6") or a 0-based
index; replace_quotes sets a pillar's quote to an explicit value.
Result: table = [{name, npv, change = npv - base_npv, edits}] starting with
base; calls = one complete pricing result per row with the quotes moved.
Inputs: trade (required), market (required), scenarios (required), market_data_source (required), +3 more. Returns: object
session_deleteB
Delete a stored session item; deleted is false if it did not exist.
Inputs: name (required). Returns: object
session_getB
Return a stored session item (value plus a summary).
Inputs: name (required). Returns: object
session_listB
List stored session items (name, kind, stored_at, a short summary).
Inputs: no named parameters. Returns: object
session_putA
Store a curve, index or market block under a name for later calls.
Args:
name: free-form handle, e.g. sofr.
kind: curve (an engine TermStructure or a build_curve result,
whose indices are kept alongside), index (an IndexDef) or
market ({curves: [...], indices: [...]}).
value: the object; it is validated against the engine schema.
market_data_source: where the numbers in value come from. user_pasted
(the user pasted or typed the numbers in this conversation), user_file
(the user attached a file/screenshot the numbers were read from),
engine_example (an engine example's pricing block, only when the user
explicitly asked to run an example), session (a market previously
stored in this session, which itself came from one of the above). There is
no value for estimated, recalled or placeholder data. If you would have to
invent numbers, do not call this tool: ask the user for the data. A
build_curve result already carries its declaration; the two must agree.
In-memory only, per server process, least-recently-used eviction at
QUANTRA_SESSION_MAX_ITEMS (default 64). Reference it later as
{"session": "<name>"} in bootstrap_curve (and pricing tools); the stored
market_data_source is reported in their notes.
Inputs: kind (required), name (required), value (required), market_data_source (required). Returns: object
swap_dv01A
Parallel DV01 of a swap: reprice with every quote of the selected curve(s) bumped.
Args:
market: as in the pricing tools (session, engine pricing block or build_curve
results).
market_data_source: where the market numbers in this call come from. user_pasted
(the user pasted or typed the numbers in this conversation), user_file (the
user attached a file/screenshot the numbers were read from), engine_example
(an engine example's pricing block, only when the user explicitly asked to run
an example), session (a market previously stored in this session, which
itself came from one of the above). There is no value for estimated, recalled or
placeholder data. If you would have to invent numbers, do not call this tool:
ask the user for the data.
trade: the swap: product (vanilla_swap | ois_swap), preset,
discounting_curve, forwarding_curve and the price_vanilla_swap /
price_ois_swap economics (swap_type, notional, fixed_rate, effective_date
'spot' | date, tenor | termination_date, spread, index_id, overrides).
bump_bp: size of the bump in basis points (default 1, positive; added to every
helper rate / spread; futures prices move by -bp/100; the method sets the sign).
method: centered (default) = (NPV(+bp) - NPV(-bp)) / 2, three engine calls;
up = NPV(+bp) - NPV(base); down = NPV(base) - NPV(-bp).
scope: all (discounting and forwarding curves together), discounting
or forwarding.
as_of: required unless market is a pricing block.
Result: base_npv, npvs (every per-call NPV: base, up, down), dv01,
dv01_definition (the exact difference taken for the method), bumped_quotes
(every quote moved per side, from/to) and calls = the complete pricing results
(each with its echoed request). Nothing else is computed; the arithmetic is cited
at quantra://methodology/connector-analytics.
Inputs: trade (required), market (required), market_data_source (required), as_of, +5 more. Returns: object
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 47 tools
Each tool targets a distinct instrument, engine endpoint, or analytics function, and descriptions clearly distinguish overlapping tools (e.g., build_curve vs build_value_curve vs curve_from_pasted_table; swap_dv01 vs key_rate_ladder vs scenario). Minor ambiguity remains among reprice/analytics tools and curve-building helpers, but an agent can select correctly from descriptions.
All names use snake_case, but the pattern is mixed: many are verb_noun (price_vanilla_swap, build_curve, list_presets), while others are noun-only (fair_rate, scenario, swap_dv01) or have a domain prefix (calendar_advance, session_put, engine_request). The convention is still readable and mostly predictable by domain.
47 tools is well above the 3-15 sweet spot and exceeds the 25+ threshold that signals a heavy surface. While the domain is complex, the sheer number increases selection cost and makes it likely that some tools overlap in agent use; each may be individually justified but the set is too large for smooth MCP use.
The surface covers health/meta, endpoint discovery, calendars, curve construction, bootstrapping, vol calibration/sampling, pricing for all major asset classes, analytics (DV01, key-rate, scenario, fair rate, reprice, compare), session storage, examples, and methodology explanation. The engine_request escape hatch prevents dead ends for any unwrapped endpoint, so coverage is effectively complete.
Maintenance
Related MCP Connectors
Price derivatives, insurance and energy models with exact sensitivities, checked against bumping.
Interest rate data and pricing: swap rates and curves, fixings, FX, caps, swaptions for 60+ indices.
Price sample option and gas storage books with AADC sensitivities, explain P&L and trace a trade
Derived & aggregated data: vol surfaces, model-implied prices, forward curves. Index from 2020.
Related MCP Servers
- AlicenseAqualityBmaintenance63 deterministic quant computation tools for autonomous financial agents. Options pricing, derivatives, risk metrics, portfolio optimization, statistics, crypto/DeFi, macro/FX, time value of money. 1,000 free calls/day, no signup required.7414MIT
- AlicenseNot gradedqualityBmaintenanceProvides option and portfolio analytics through validated numerical methods, exposing tools for pricing, Greeks, implied volatility, volatility surfaces, and American options via MCP.MIT
- AlicenseNot gradedqualityBmaintenanceEnables users to compute European option prices and sensitivity metrics, run Monte Carlo GBM simulations, calculate historical/parametric VaR/CVaR, evaluate bond duration and convexity, and interpolate Nelson-Siegel yield curves through MCP.7MIT
- AlicenseNot gradedqualityNot gradedmaintenanceEnables analytical pricing of European options and calculation of first- and second-order Greeks including Delta, Gamma, Vega, Theta, and Rho through MCP. It also supports related quantitative finance analytics such as Monte Carlo simulations, VaR/CVaR, bond duration, and yield curve interpolation.MIT