protogrid

Search / com.currencyguard/guard-pricing

CurrencyGuard Guard Pricing

R0· no sign-in

FX protection for SMEs — price Guards, live spot/forward rates, settlement dates, and more.

v1.0.0 · active · repository · website · descriptor JSON · versions

An agent can connect right now, no human step.Remote endpoint, no authentication, reachable on the last probe.
Quality66needs work
Trust89of 100
Uptime, 30 days100%
Latency p50416 ms

Connect

8 clients · secrets stay placeholders
{
  "mcpServers": {
    "guard-pricing": {
      "type": "http",
      "url": "https://api.currencyguard.com/mcp"
    }
  }
}
claude mcp add --transport http guard-pricing https://api.currencyguard.com/mcp
[mcp_servers.guard-pricing]
url = "https://api.currencyguard.com/mcp"
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "guard-pricing": {
      "type": "remote",
      "url": "https://api.currencyguard.com/mcp",
      "enabled": true
    }
  }
}
{
  "mcpServers": {
    "guard-pricing": {
      "type": "http",
      "url": "https://api.currencyguard.com/mcp"
    }
  },
  "deeplink": "cursor://anysphere.cursor-deeplink/mcp/install?name=guard-pricing&config=eyJ0eXBlIjoiaHR0cCIsInVybCI6Imh0dHBzOi8vYXBpLmN1cnJlbmN5Z3VhcmQuY29tL21jcCJ9"
}
{
  "servers": {
    "guard-pricing": {
      "type": "http",
      "url": "https://api.currencyguard.com/mcp"
    }
  }
}
{
  "mcpServers": {
    "guard-pricing": {
      "httpUrl": "https://api.currencyguard.com/mcp"
    }
  }
}
extensions:
  "guard-pricing":
    enabled: true
    name: "guard-pricing"
    type: streamable_http
    uri: "https://api.currencyguard.com/mcp"
    timeout: 300

Quality 66 / 100needs work

protocol75 · weight 25
  • warn
    protocol.modernnewest supported version is 2025-11-25; 2026-07-28 not supported, older versions are deprecated until 2027-07-28
  • n/a
    protocol.statelessonly applies to 2026-07-28 servers
  • pass
    protocol.transportstreamable HTTP
  • n/a
    protocol.list_ttlonly applies to 2026-07-28 servers
authorizationn/a · weight 15
  • n/a
    auth.prm, auth.as_metadata, auth.cimdno remote uses OAuth
  • n/a
    auth.secret_in_urlno templated URL
tool hygiene79 · weight 30
  • pass
    tools.descriptionsevery tool has a description
  • warn
    tools.description_length3 tools have descriptions over 1,024 characters, which crowds the context
  • pass
    tools.schemasevery tool has an object input schema
  • pass
    tools.annotations11 of 11 tools declare readOnlyHint or destructiveHint
  • fail
    tools.directory_hintsno tool declares all four of readOnlyHint, destructiveHint, idempotentHint and openWorldHint; missing: get_spot_rate (idempotentHint, openWorldHint); compare_guard_with_forward (idempotentHint, openWorldHint); net_exposure (idempotentHint, openWorldHint); …
  • pass
    tools.token_costabout 5,386 tokens to load every tool
  • pass
    tools.api_dumptools are not a one-to-one API dump
stability25 · weight 15
  • warn
    stability.changes19 tool changes in 30 days
  • fail
    stability.rug_pull1 tools kept their name but changed most of their description in 30 days; review before trusting them
dependenciesn/a · weight 15
  • n/a
    deps.known_vulns, deps.mcp_sdk_version, deps.resolvableno npm or PyPI package

11 tools, about 5,386 tokens to load them all · tool set 2dad133c4812 · tools last changed 2026-10-19 · checked 2026-10-20 11:08 UTC

Tool changes

  • net_exposurechangeddescription
    before

    Net an SME's open foreign-currency bills and invoices, so that a receipt due on or before a payment in the same currency is shown as funding it. Returns the residual on every bill and invoice, a trace of which invoice funds which bill and for how much, per-bucket totals, dependency statements, and series for a ladder chart. It prices nothing: call price_guard on each residual separately, with the item's own due date as settlementDate. Never offsets across currencies. Items in base_currency are ignored. Cancelled items are excluded. Overdue items are listed separately and never netted. Set carry to true only when the client keeps receipts in a wallet or account in that currency, so a surplus can fund a later payment. If you do not know, ask the user whether they hold an account in each foreign currency before calling; do not guess. If their accounting platform is connected, offer to look up its bank accounts and their currencies there, and use what you find. If the answer is "not sure", call the tool twice, carry true and carry false, and show both charts; each carries its own scenario title, and chart_series.scenario holds the same words. THE RESULT HAS TWO PARTS: the JSON, then a PNG of the ladder chart rendered by the service. Show that image to the user as it is. PRESENTING THE RESULT: chart_series.currencies[ccy].open[] is the exposure. Present each open item on its own due date, with its label. Never add open items into one net figure, and never convert them to the base currency at spot. Do not call price_guard or show a Guard price unless the user asks for a price. If the user asks what they can do, lay out three things as facts and stop: do nothing (the amount stays exposed until paid), a forward from a bank or a payment provider (fixes the rate, provider margin inside the rate, an obligation that may need initial margin and margin calls, settled even if the payment does not happen), a Guard (fee known up front, market rate used if better, nothing further to pay if the payment does not happen). Do not rank them or say which fits. Never use the word "hedge". Do not draw a chart of your own from these numbers. Spec: docs/specs/net_exposure.md.

    after · 92% of words in common

    Net an SME's open foreign-currency bills and invoices, so that a receipt due on or before a payment in the same currency is shown as funding it. Returns the residual on every bill and invoice, a trace of which invoice funds which bill and for how much, per-bucket totals, dependency statements, and series for a ladder chart. It prices nothing: call price_guard on each residual separately, with the item's own due date as settlementDate. Never offsets across currencies. Items in base_currency are ignored. Cancelled items are excluded. Overdue items are listed separately and never netted. Set carry to true only when the client keeps receipts in a wallet or account in that currency, so a surplus can fund a later payment. If you do not know, ask the user whether they hold an account in each foreign currency before calling; do not guess. If their accounting platform is connected, offer to look up its bank accounts and their currencies there, and use what you find. If the answer is "not sure", call the tool twice, carry true and carry false, and show both charts; each carries its own scenario title, and chart_series.scenario holds the same words. THE RESULT HAS TWO PARTS: the JSON, then a PNG of the ladder chart rendered by the service. Show that image to the user as it is. PRESENTING THE RESULT: chart_series.currencies[ccy].open[] is the exposure. Present each open item on its own due date, with its label. Never add open items into one net figure, and never convert them to the base currency at spot. Do not call price_guard or show a Guard price unless the user asks for a price. If the user asks what they can do, lay out three things as facts and stop: do nothing (the amount stays exposed until paid), a forward from a bank or a payment provider (fixes the rate, provider margin inside the rate, an obligation that may need initial margin and margin calls, settled even if the payment does not happen), a Guard (fee known up front, market rate used if better, nothing further to pay if the payment does not happen). Do not rank them or say which fits. Never use the word "hedge". Do not draw a chart of your own from these numbers. DATES: the result carries today, the date the tool used. A due date the user gave without a year means the next such date on or after today, never a past year. If the result carries a warnings[] entry saying every item is before today, the dates are probably missing a year: confirm with the user and call again. Spec: docs/specs/net_exposure.md.

  • price_guardchangeddescription
    before

    Price a Guard — CurrencyGuard's FX protection product for real future payments or receipts. If a tenor like '3 months' is given, call resolve_settlement_date first to get the exact date, then call this tool. Returns: guardType (Guard-Pay or Guard-Receive), guardRate, guardFee, guardFeePercent, effectiveRate, guardAmount (the foreign amount converted at the Guard rate, in the home currency, WITHOUT the fee), foreignAmount, spotRate, settlementDate, settlementWindowOpens, valid, errors. The Guard fee is separate money. A payer funds guardAmount plus guardFee; a receiver nets guardAmount minus guardFee. effectiveRate is that all-in figure expressed as a rate. All quotes are indicative, because a Guard is bought through the customer's payment provider, who sets the final rate and fee. Say that reason when you say "indicative".

    after · 61% of words in common

    Price a Guard — CurrencyGuard's FX protection product for real future payments or receipts. If a tenor like '3 months' is given, call resolve_settlement_date first to get the exact date, then call this tool. Returns: guardType (Guard-Pay or Guard-Receive), guardRate, guardFee (in the home currency), guardFeePct (a FRACTION: 0.0096 means 0.96%), guardFeePercent (the same figure written as a percentage, e.g. "0.96%" — quote this one), effectiveRate, guardAmount (the foreign amount converted at the Guard rate, in the home currency, WITHOUT the fee), foreignAmount, spotRate, settlementDate, settlementWindowFrom (the first day the Guard rate can be used; the window runs from there to settlementDate, counted in business days on the trading calendar, so over holidays it opens earlier than 14 calendar days), payLaterCreditFee (the extra charged if the fee is paid at settlement instead of up front), valid, errors, stale. Pilot limit: the Guard amount cannot exceed 1,000,000 in the home currency. Say so before quoting if the amount is clearly above it. The Guard fee is separate money. A payer funds guardAmount plus guardFee; a receiver nets guardAmount minus guardFee. effectiveRate is that all-in figure expressed as a rate. All quotes are indicative, because a Guard is bought through the customer's payment provider, who sets the final rate and fee. Say that reason when you say "indicative".

  • compare_guard_with_forwardchangeddescription, input schema
    before

    Use when a user asks whether a Guard is worth it, how it compares with a forward contract from their bank or provider, or what happens if they do nothing. Prices the Guard and sets it beside a forward and beside no protection, all on the same settlement date, and spells out the cash each one demands — which is where they really differ. A forward usually looks cheaper on the rate and ties up far more cash: a deposit at the start, and more cash demanded on dates the client does not choose if the market moves against them. If a tenor like '3 months' is given, call resolve_settlement_date first. DO NOT ALSO CALL price_guard. This returns the Guard rate, fee and amount itself, priced in the same moment as the forward it is compared against. Calling both prices the Guard twice seconds apart, and the market moves between them — the answer then shows two different fees for one Guard. Returns rates, the home-currency amount under each, cash required up front, cash demanded under each adverse move, what happens if the payment is cancelled, what happens if the market improves, and the worst case for each. QUOTE THE ALL-IN COST, NOT THE RATE ROW. homeCurrencyAmount.forward already contains the provider margin, because the margin is in the rate, but homeCurrencyAmount.guard does NOT contain the Guard fee. Compare homeCurrencyAmount.guardAllIn with homeCurrencyAmount.forward: those two both carry every cost of their own product. Comparing guard with forward overstates the Guard, by the whole fee. rates.effectiveRate is the same all-in figure expressed as a rate, for setting beside a provider's quoted rate. The forward figures rest on assumptions, which are returned with the answer: CurrencyGuard does not sell forwards and does not know what any particular provider would quote. State the assumptions when you present this and say they can be changed.

    after · 56% of words in common

    Use when a user asks whether a Guard is worth it, how it compares with a forward contract from their bank or provider, or what happens if they do nothing. ASK BEFORE YOU CALL. The forward side of this comparison should be the customer's own numbers, not CurrencyGuard's guesses. Ask three things first: (1) the forward rate their provider last quoted them for this payment, (2) whether the provider gives them an unsecured line with no deposit, or asks for an initial margin and at what percentage, and (3) at what adverse move the provider demands more cash. Pass what they give you as providerForwardRate, initialMarginPct (0 for an unsecured line) and marginCallThresholdPct. Only call with none of them when the customer cannot answer, and then say in your answer that the forward figures are illustrative defaults. DO NOT RANK. Present every row in the order the output gives it: rates, home-currency amount, cash up front, cash demanded under adverse moves, outcomes under favourable and adverse moves, cancellation, market improvement, worst case. Do not say which one wins, which looks bad, which is cheaper overall, or which the customer should choose. State the numbers. The decision is the customer's. cashNature says what kind of money each figure is: the Guard fee is spent, a forward's deposit and margin calls are held and returned at settlement. Say so when you show them. Held cash is not a cost. outcomes runs each move in both directions. In the favourable rows the Guard lapses and the fee is spent for nothing, and the forward is locked out of the better rate. Show both directions, not only the adverse one. READ OUT comparability.protection AND comparability.pricing beside the cost row, every time. A Guard and a forward are different kinds of protection, and the Guard rate here is mid-market while a payment provider may apply a margin to it or to the fee. The cost row is therefore not a like-for-like price comparison. If a tenor like '3 months' is given, call resolve_settlement_date first. DO NOT ALSO CALL price_guard. This returns the Guard rate, fee and amount itself, priced in the same moment as the forward it is compared against. Calling both prices the Guard twice seconds apart, and the market moves between them — the answer then shows two different fees for one Guard. In the cost row, QUOTE THE ALL-IN COST, NOT THE RATE ROW. homeCurrencyAmount.forward already contains the provider margin, because the margin is in the rate, but homeCurrencyAmount.guard does NOT contain the Guard fee. Compare homeCurrencyAmount.guardAllIn with homeCurrencyAmount.forward: those two both carry every cost of their own product. Comparing guard with forward overstates the Guard, by the whole fee. rates.effectiveRate is the same all-in figure expressed as a rate, for setting beside a provider's quoted rate. assumptions.source says, figure by figure, whether the forward side is the customer's data (CUSTOMER, PROVIDER_QUOTE) or ours (DEFAULT, MARKET_CURVE_PLUS_MARGIN). Read assumptions.note out with the answer. Say "your provider's rate" for the customer's figures and "an assumed 5% deposit" for ours. Never present a default as a quote. The Guard figures are indicative, because a Guard is bought through the customer's payment provider, who sets the final rate and fee. Say that reason when you say "indicative".

  • price_guardchangeddescription
    before

    Price a Guard — CurrencyGuard's FX protection product for real future payments or receipts. If a tenor like '3 months' is given, call resolve_settlement_date first to get the exact date, then call this tool. Returns: guardType (Guard-Pay or Guard-Receive), guardRate, guardFee, guardFeePercent, effectiveRate, guardAmount (home currency equivalent), foreignAmount, spotRate, settlementDate, settlementWindowOpens, valid, errors. All quotes are indicative.

    after · 61% of words in common

    Price a Guard — CurrencyGuard's FX protection product for real future payments or receipts. If a tenor like '3 months' is given, call resolve_settlement_date first to get the exact date, then call this tool. Returns: guardType (Guard-Pay or Guard-Receive), guardRate, guardFee, guardFeePercent, effectiveRate, guardAmount (the foreign amount converted at the Guard rate, in the home currency, WITHOUT the fee), foreignAmount, spotRate, settlementDate, settlementWindowOpens, valid, errors. The Guard fee is separate money. A payer funds guardAmount plus guardFee; a receiver nets guardAmount minus guardFee. effectiveRate is that all-in figure expressed as a rate. All quotes are indicative, because a Guard is bought through the customer's payment provider, who sets the final rate and fee. Say that reason when you say "indicative".

  • compare_guard_with_forwardchangeddescription
    before

    Use when a user asks whether a Guard is worth it, how it compares with a forward contract from their bank or provider, or what happens if they do nothing. Prices the Guard and sets it beside a forward and beside no protection, all on the same settlement date, and spells out the cash each one demands — which is where they really differ. A forward usually looks cheaper on the rate and ties up far more cash: a deposit at the start, and more cash demanded on dates the client does not choose if the market moves against them. If a tenor like '3 months' is given, call resolve_settlement_date first. DO NOT ALSO CALL price_guard. This returns the Guard rate, fee and amount itself, priced in the same moment as the forward it is compared against. Calling both prices the Guard twice seconds apart, and the market moves between them — the answer then shows two different fees for one Guard. Returns rates, the home-currency amount under each, cash required up front, cash demanded under each adverse move, what happens if the payment is cancelled, what happens if the market improves, and the worst case for each. The forward figures rest on assumptions, which are returned with the answer: CurrencyGuard does not sell forwards and does not know what any particular provider would quote. State the assumptions when you present this and say they can be changed.

    after · 83% of words in common

    Use when a user asks whether a Guard is worth it, how it compares with a forward contract from their bank or provider, or what happens if they do nothing. Prices the Guard and sets it beside a forward and beside no protection, all on the same settlement date, and spells out the cash each one demands — which is where they really differ. A forward usually looks cheaper on the rate and ties up far more cash: a deposit at the start, and more cash demanded on dates the client does not choose if the market moves against them. If a tenor like '3 months' is given, call resolve_settlement_date first. DO NOT ALSO CALL price_guard. This returns the Guard rate, fee and amount itself, priced in the same moment as the forward it is compared against. Calling both prices the Guard twice seconds apart, and the market moves between them — the answer then shows two different fees for one Guard. Returns rates, the home-currency amount under each, cash required up front, cash demanded under each adverse move, what happens if the payment is cancelled, what happens if the market improves, and the worst case for each. QUOTE THE ALL-IN COST, NOT THE RATE ROW. homeCurrencyAmount.forward already contains the provider margin, because the margin is in the rate, but homeCurrencyAmount.guard does NOT contain the Guard fee. Compare homeCurrencyAmount.guardAllIn with homeCurrencyAmount.forward: those two both carry every cost of their own product. Comparing guard with forward overstates the Guard, by the whole fee. rates.effectiveRate is the same all-in figure expressed as a rate, for setting beside a provider's quoted rate. The forward figures rest on assumptions, which are returned with the answer: CurrencyGuard does not sell forwards and does not know what any particular provider would quote. State the assumptions when you present this and say they can be changed.

  • net_exposureadded

    Net an SME's open foreign-currency bills and invoices, so that a receipt due on or before a payment in the same currency is shown as funding it. Returns the residual on every bill and invoice, a trace of which invoice funds which bill and for how much, per-bucket totals, dependency statements, and series for a ladder chart. It prices nothing: call price_guard on each residual separately, with the item's own due date as settlementDate. Never offsets across currencies. Items in base_currency are ignored. Cancelled items are excluded. Overdue items are listed separately and never netted. Set carry to true only when the client keeps receipts in a wallet or account in that currency, so a surplus can fund a later payment. If you do not know, ask the user whether they hold an account in each foreign currency before calling; do not guess. If their accounting platform is connected, offer to look up its bank accounts and their currencies there, and use what you find. If the answer is "not sure", call the tool twice, carry true and carry false, and show both charts; each carries its own scenario title, and chart_series.scenario holds the same words. THE RESULT HAS TWO PARTS: the JSON, then a PNG of the ladder chart rendered by the service. Show that image to the user as it is. PRESENTING THE RESULT: chart_series.currencies[ccy].open[] is the exposure. Present each open item on its own due date, with its label. Never add open items into one net figure, and never convert them to the base currency at spot. Do not call price_guard or show a Guard price unless the user asks for a price. If the user asks what they can do, lay out three things as facts and stop: do nothing (the amount stays exposed until paid), a forward from a bank or a payment provider (fixes the rate, provider margin inside the rate, an obligation that may need initial margin and margin calls, settled even if the payment does not happen), a Guard (fee known up front, market rate used if better, nothing further to pay if the payment does not happen). Do not rank them or say which fits. Never use the word "hedge". Do not draw a chart of your own from these numbers. Spec: docs/specs/net_exposure.md.

  • get_historic_best_worstchangedinput schema
  • hello_worldremoved

    Return the text "Hello Agentic World!". Use it to check that the CurrencyGuard MCP server answers. It takes no input and calls no endpoint.

  • compare_guard_with_forwardadded

    Use when a user asks whether a Guard is worth it, how it compares with a forward contract from their bank or provider, or what happens if they do nothing. Prices the Guard and sets it beside a forward and beside no protection, all on the same settlement date, and spells out the cash each one demands — which is where they really differ. A forward usually looks cheaper on the rate and ties up far more cash: a deposit at the start, and more cash demanded on dates the client does not choose if the market moves against them. If a tenor like '3 months' is given, call resolve_settlement_date first. DO NOT ALSO CALL price_guard. This returns the Guard rate, fee and amount itself, priced in the same moment as the forward it is compared against. Calling both prices the Guard twice seconds apart, and the market moves between them — the answer then shows two different fees for one Guard. Returns rates, the home-currency amount under each, cash required up front, cash demanded under each adverse move, what happens if the payment is cancelled, what happens if the market improves, and the worst case for each. The forward figures rest on assumptions, which are returned with the answer: CurrencyGuard does not sell forwards and does not know what any particular provider would quote. State the assumptions when you present this and say they can be changed.

  • request_provider_availabilityadded

    Find out whether Guards can be bought through a particular payment provider or bank. A Guard is always bought through a payment provider, so this cannot be answered without knowing which one the user pays through — CurrencyGuard checks and replies. ASK BEFORE CALLING. Tell the user plainly that their provider, and their email address if they give one, will be sent to CurrencyGuard so they can answer. Call this only after they say yes. The email address is optional: the provider on its own is a complete enquiry, and without an address there is simply no one to reply to. Never take an email address from earlier in the conversation — only one the user has just given for this purpose. Never call this more than once in a conversation, and never after the user has declined.

Showing the latest 10. Full history: list_changes · trend: quality JSON.

Checks run on what our credential-free, read-only probes observe; tools are never called and no code audit is performed. How it is computed.

Trust 89 / 100

provenance100
liveness100
freshness45
hygiene100

+repository +namespace-matches-repo +dns-namespace +website +reachable +uptime-100% -stale-181d

Derived from observable signals (official registry feed and our own credential-free probes); no code audit performed. How it is computed.

Endpoints

remoteauthreachableuptime 30dp50protocollast ok
https://api.currencyguard.com/mcp streamable-httpnoneyes100%416 ms2025-11-252026-10-20

Tools (11)

compare_guard_with_forwardread-onlyUse when a user asks whether a Guard is worth it, how it compares with a forward contract from their bank or provider, or what happens if they do nothing. ASK BEFORE YOU CALL. The forward side of this comparison should be the customer's own numbers, not CurrencyGuard's guesses. Ask three things first: (1) the forward rate their provider last quoted them for this payment, (2) whether the provider gives them an unsecured line with no deposit, or asks for an initial margin and at what percentage, and (3) at what adverse move the provider demands more cash. Pass what they give you as providerForwardRate, initialMarginPct (0 for an unsecured line) and marginCallThresholdPct. Only call with none of them when the customer cannot answer, and then say in your answer that the forward figures are illustrative defaults. DO NOT RANK. Present every row in the order the output gives it: rates, home-currency amount, cash up front, cash demanded under adverse moves, outcomes under favourable and adverse moves, cancellation, market improvement, worst case. Do not say which one wins, which looks bad, which is cheaper overall, or which the customer should choose. State the numbers. The decision is the customer's. cashNature says what kind of money each figure is: the Guard fee is spent, a forward's deposit and margin calls are held and returned at settlement. Say so when you show them. Held cash is not a cost. outcomes runs each move in both directions. In the favourable rows the Guard lapses and the fee is spent for nothing, and the forward is locked out of the better rate. Show both directions, not only the adverse one. READ OUT comparability.protection AND comparability.pricing beside the cost row, every time. A Guard and a forward are different kinds of protection, and the Guard rate here is mid-market while a payment provider may apply a margin to it or to the fee. The cost row is therefore not a like-for-like price comparison. If a tenor like '3 months' is given, call resolve_settlement_date first. DO NOT ALSO CALL price_guard. This returns the Guard rate, fee and amount itself, priced in the same moment as the forward it is compared against. Calling both prices the Guard twice seconds apart, and the market moves between them — the answer then shows two different fees for one Guard. In the cost row, QUOTE THE ALL-IN COST, NOT THE RATE ROW. homeCurrencyAmount.forward already contains the provider margin, because the margin is in the rate, but homeCurrencyAmount.guard does NOT contain the Guard fee. Compare homeCurrencyAmount.guardAllIn with homeCurrencyAmount.forward: those two both carry every cost of their own product. Comparing guard with forward overstates the Guard, by the whole fee. rates.effectiveRate is the same all-in figure expressed as a rate, for setting beside a provider's quoted rate. assumptions.source says, figure by figure, whether the forward side is the customer's data (CUSTOMER, PROVIDER_QUOTE) or ours (DEFAULT, MARKET_CURVE_PLUS_MARGIN). Read assumptions.note out with the answer. Say "your provider's rate" for the customer's figures and "an assumed 5% deposit" for ours. Never present a default as a quote. The Guard figures are indicative, because a Guard is bought through the customer's payment provider, who sets the final rate and fee. Say that reason when you say "indicative".
explain_guard_productread-onlyExplain the Guard product using CurrencyGuard's approved product and FAQ content. Covers: what the Guard is, how it works, who it is for, how it compares to forwards or options, and legal, regulatory, accounting, or eligibility questions.
get_forward_rateread-onlyUse when you need a forward FX rate. tenor accepts either a period such as 1W, 1M, 3M, 6M, 1Y, or an exact date in ISO form YYYY-MM-DD. Use an exact date whenever you need the forward for the same day a Guard settles: a period resolves to the forward curve's own date, which can be several days away, and a comparison across two different dates is misleading. Rates are taken from the market forward curve, rounded, and for illustration purposes only — not for execution. Returns: forwardRate (indicative mid outright = spot + forward points), forwardPoints (in pips, e.g. -3.1 means the forward rate is 3.1 pips below spot), spotMid (indicative spot mid rate for comparison), settlementDate (the date the rate is for). Negative forward points mean the forward rate is below spot; positive means above. Example: base=GBP, quote=USD, tenor=2026-12-29 returns the GBPUSD forward for that day.
get_historic_best_worstread-onlyAnalyze historic best/worst FX performance for a currency pair over a Guard's duration. Uses Bank of England historic rates. Returns a 'performances' array with 6 entries — BEST and WORST for each of three lookback periods (5, 10, 25 years). Each entry contains: type, lookbackYears, startDate/endDate, startRate/endRate, performancePercentage, startAmount, finalAmount, deltaAmount. For Guard-Pay: negative delta = cost decreased = BEST; positive delta = cost increased = WORST. For Guard-Receive: positive delta = receipt increased = BEST; negative delta = receipt decreased = WORST. Parameters must match the values used in the preceding price_guard call, including payReceive (PAY or RECEIVE).
get_spot_rateread-onlyGet an indicative spot FX rate for a currency pair. Returns rounded bid, ask, and mid rates for illustration purposes only — not for execution. Example: base=GBP, quote=USD returns the GBPUSD rate.
list_supported_currenciesread-onlyList the currency pairs currently available for Guard pricing. Always call this rather than assuming which pairs are supported — the list is configuration-driven and changes.
net_exposureread-onlyNet an SME's open foreign-currency bills and invoices, so that a receipt due on or before a payment in the same currency is shown as funding it. Returns the residual on every bill and invoice, a trace of which invoice funds which bill and for how much, per-bucket totals, dependency statements, and series for a ladder chart. It prices nothing: call price_guard on each residual separately, with the item's own due date as settlementDate. Never offsets across currencies. Items in base_currency are ignored. Cancelled items are excluded. Overdue items are listed separately and never netted. Set carry to true only when the client keeps receipts in a wallet or account in that currency, so a surplus can fund a later payment. If you do not know, ask the user whether they hold an account in each foreign currency before calling; do not guess. If their accounting platform is connected, offer to look up its bank accounts and their currencies there, and use what you find. If the answer is "not sure", call the tool twice, carry true and carry false, and show both charts; each carries its own scenario title, and chart_series.scenario holds the same words. THE RESULT HAS TWO PARTS: the JSON, then a PNG of the ladder chart rendered by the service. Show that image to the user as it is. PRESENTING THE RESULT: chart_series.currencies[ccy].open[] is the exposure. Present each open item on its own due date, with its label. Never add open items into one net figure, and never convert them to the base currency at spot. Do not call price_guard or show a Guard price unless the user asks for a price. If the user asks what they can do, lay out three things as facts and stop: do nothing (the amount stays exposed until paid), a forward from a bank or a payment provider (fixes the rate, provider margin inside the rate, an obligation that may need initial margin and margin calls, settled even if the payment does not happen), a Guard (fee known up front, market rate used if better, nothing further to pay if the payment does not happen). Do not rank them or say which fits. Never use the word "hedge". Do not draw a chart of your own from these numbers. DATES: the result carries today, the date the tool used. A due date the user gave without a year means the next such date on or after today, never a past year. If the result carries a warnings[] entry saying every item is before today, the dates are probably missing a year: confirm with the user and call again. Spec: docs/specs/net_exposure.md.
price_guardread-onlyPrice a Guard — CurrencyGuard's FX protection product for real future payments or receipts. If a tenor like '3 months' is given, call resolve_settlement_date first to get the exact date, then call this tool. Returns: guardType (Guard-Pay or Guard-Receive), guardRate, guardFee (in the home currency), guardFeePct (a FRACTION: 0.0096 means 0.96%), guardFeePercent (the same figure written as a percentage, e.g. "0.96%" — quote this one), effectiveRate, guardAmount (the foreign amount converted at the Guard rate, in the home currency, WITHOUT the fee), foreignAmount, spotRate, settlementDate, settlementWindowFrom (the first day the Guard rate can be used; the window runs from there to settlementDate, counted in business days on the trading calendar, so over holidays it opens earlier than 14 calendar days), payLaterCreditFee (the extra charged if the fee is paid at settlement instead of up front), valid, errors, stale. Pilot limit: the Guard amount cannot exceed 1,000,000 in the home currency. Say so before quoting if the amount is clearly above it. The Guard fee is separate money. A payer funds guardAmount plus guardFee; a receiver nets guardAmount minus guardFee. effectiveRate is that all-in figure expressed as a rate. All quotes are indicative, because a Guard is bought through the customer's payment provider, who sets the final rate and fee. Say that reason when you say "indicative".
price_guard_extensionread-onlyGet an indicative price for extending a Guard to a later settlement date. Estimates the additional cost using: (1) the guard fee difference between extended and original expiry, (2) the guard spread cost from the roll, and (3) the CurrencyGuard extension margin. Returns a breakdown: extensionCost = feeDifference + guardSpreadCost + extensionMargin. Both the original and extended quotes are priced at the same guard rate (the original quote's Guard rate), so the fee difference reflects purely the longer tenor, not market movement. Use this when a customer asks 'how much would it cost to extend my Guard by X months?' Parameters match price_guard plus the two dates.
request_provider_availabilityFind out whether Guards can be bought through a particular payment provider or bank. A Guard is always bought through a payment provider, so this cannot be answered without knowing which one the user pays through — CurrencyGuard checks and replies. ASK BEFORE CALLING. Tell the user plainly that their provider, and their email address if they give one, will be sent to CurrencyGuard so they can answer. Call this only after they say yes. The email address is optional: the provider on its own is a complete enquiry, and without an address there is simply no one to reply to. Never take an email address from earlier in the conversation — only one the user has just given for this purpose. Never call this more than once in a conversation, and never after the user has declined.
resolve_settlement_dateread-onlyResolve a relative time period (tenor) to a valid business settlement date for a currency pair. Use this when a user says '3 months', '6 months', '1 year', etc. instead of an exact date. The tenor format is: 1D (days), 1W (weeks), 1M (months), 1Y (years). Examples: '3M' = 3 months, '6M' = 6 months, '1Y' = 1 year. The returned date accounts for weekends and public holidays in both currencies' financial centres. Use the returned settlementDate as the exact date parameter for price_guard.

Schemas: list_tools.

Similar MCP servers

Official server.json
{
  "name": "com.currencyguard/guard-pricing",
  "title": "CurrencyGuard Guard Pricing",
  "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
  "remotes": [
    {
      "url": "https://api.currencyguard.com/mcp",
      "type": "streamable-http"
    }
  ],
  "version": "1.0.0",
  "repository": {
    "url": "https://gitlab.com/currencyguard/server",
    "source": "gitlab"
  },
  "websiteUrl": "https://www.currencyguard.com",
  "description": "FX protection for SMEs — price Guards, live spot/forward rates, settlement dates, and more."
}