Skip to main content
Glama

Server Details

Build, backtest and analyse investment strategies

Ownership verified
Status
Healthy
Uptime
95.5% over the last 24 hours
OAuth
Works in Glama
Last Tested
Transport
Streamable HTTP · MCP 2025-11-25
URL
ChatGPT
–
Claude
–

TDQS

A3.8/5.0

Scored across 47 tools

Disambiguation4/5

The set is deliberately cross-referenced: build_* saves, solve_* returns ad hoc weights, screen_* returns unweighted lists, and the describe_* tools target distinct analytic views. Still, with many paired tools (build vs solve, screen vs solve, describe_portfolio_weights vs describe_holdings), an agent must read long descriptions to avoid misselection.

Naming Consistency5/5

All names use a consistent snake_case verb_noun pattern, such as list_portfolios, build_equity_strategy, describe_portfolio_risk, and revoke_share. Multi-word names remain readable and follow the same convention throughout.

Tool Count2/5

At 47 tools, the surface is very heavy even for a broad portfolio analytics platform. While many tools are specialized and cross-referenced, the count is well beyond the 3-15 well-scoped range and increases selection burden.

Completeness4/5

Coverage is broad: discovery, strategy building and solving, backtesting, portfolio analytics, simulations, alerts, sharing, and external account sync are all present. Minor gaps remain, such as no direct non-external account creation/update path and no explicit fund-list read/list tool.

Publisher details

Operator
Analyzera Global AB
Operator website
https://analyzera.com
Vendor relationship
First-party
Privacy policy
Not provided
Trust center
Not available
Restrictions
Free and paid plans available

Available Tools

47 tools
assign_strategyLink an account to a strategyA
DestructiveIdempotent
Inspect

Make one of the client's accounts TRACK a strategy, for describe_drift and drift alerts; strategy_id 0 unlinks it. Tracking only — nothing is traded. Account ids come from list_portfolios' 'accounts' group.

Inputs: account_id (required), strategy_id. Returns: result

build_allocation_strategyBuild a multi-asset allocationA
Destructive
Inspect

Build a multi-asset allocation, or rewrite one, and return its weights. Writes.

``strategy_id`` edits that strategy (only one this client owns). An edit replaces
the definition: ``items`` becomes the whole portfolio and omitted caps revert to
unconstrained; ``name`` may be omitted to keep it. Editing one with a track
record rebuilds that history in the background.

Personalizing a model portfolio (one the client saved, often to tailor it for one
of their clients) is a copy, not an edit: ask which one, read its
``get_strategy_definition``, then build without ``strategy_id`` with the changes.

``items`` is the portfolio. Each is an instrument (``asset_id``), a strategy
(``strategy_id``, from ``find_portfolios``; its holdings are published first), or
an ``instrument`` of 'broad_equity', 'long_bond' or 'short_bond', resolved to the
client's currency default (see ``get_default_instruments``), so one call works in
any currency and needs no ``asset_class``.

``weight`` pins an item; unpinned items share the rest by risk parity, so a calmer
line weighs more. ``min_weight`` / ``max_weight`` bound an item without
pinning it. With a risk target, a long bond is added if no bond line is listed.
``short_rate_asset_id`` (id from ``find_assets``; default: the currency's) is a
reserve, not a line: held only when the target is below what the lines reach,
and only as much as needed. A short-duration fund listed in ``items`` is a line
instead, and risk parity gives it a large weight because it barely moves.

``risk_level`` targets the 0-10 ladder (anchors 0/1/2/5/8/10, the rest
interpolated); None is static: exactly its pins. ``loss_tolerance`` is a worst
month (0.10 = 10%); with both, the tighter wins.

Caps (None: unconstrained) look through strategy items:
``max_equity_weight`` / ``max_alternative_weight`` total by asset class;
``max_tactical_weight`` totals items tagged ``diversification='narrow'`` (a cap
with no tagged item is rejected); ``max_asset_weight`` / ``max_sector_weight`` /
``max_country_weight`` apply to the underlying equities. These are construction
parameters; no client profile is read.

``history_years`` starts no earlier than the first quarter end after the
youngest strategy item began.

``glide_target_date`` (needs ``risk_level``) glides toward the date the client
names: each rebalance holds the lower of ``risk_level`` and the published horizon
ceiling for the time left (``get_risk_ceiling_for_horizon``), reaching level 2
about a year before the date. ``glide`` is the yearly schedule. A backtest runs
today's level over the whole history.

``signal`` tilts or filters unpinned items at each rebalance on data up to its
observation date; an unscored item counts as average. It carries a client's own
momentum or factor rule; without it, items are sized by risk alone.

Inputs: items (required), name, signal, backtest, +13 more.

build_equity_strategyBuild an equity strategyA
Destructive
Inspect

Build a single-stock equity strategy, or rewrite one, and return its weights. Writes.

``strategy_id`` edits that strategy (only one this client owns). An edit replaces
the whole definition: omitted arguments revert to their defaults, so restate the
rest from ``get_strategy_definition``; ``name`` may be omitted to keep it. An edit
to a strategy with a track record rebuilds it in the background (``backtest_key``).

The universe is screened at every rebalance, so a backtest holds what the screen
picked on each date; ``regions`` is required. A screen or weighting is saved by
its ``request`` plus a name. ``asset_ids`` instead fixes the universe for the whole
history (other universe arguments go inert): a list the client brings. Ids copied
from a screen, a weighting or today's holdings give a backtest hindsight bias.

- ``sizes`` — 'large', 'mid', 'small', 'micro'; default large and mid.
- ``sectors`` / ``industries`` — GICS sectors, or GICS codes of 4, 6 or 8 digits
  from ``find_gics``; a code inside a named sector narrows it, else adds to it.
- ``esg_filter`` — 'exclude_worst' drops the exclusion list and the worst ESG
  decile; 'positive_tilt' drops the list and keeps the best three quarters.
- ``themes`` — maintained theme codes ('artificial_intelligence', 'defence', ...);
  several keep the members of any of them.

A lone theme or sector the catalogue carries returns its rows instead of building
(``build_anyway=True`` builds anyway); with a region, ESG screen, tilt or
non-default weighting it builds, and reports the rows beside it.

``fundamentals`` ranks the survivors on factor axes, each by default at its
usual end (cheap, high momentum, low debt, profitable, small, low volatility,
high yield, high growth). Valuation high is EXPENSIVE; 'quality' splits its
share between profitability and leverage. It keeps the top
``fundamentals_percentage_select`` (25% default); ~0.10 is a deep tilt, above
~0.50 a quality screen. ``min_dividend_yield`` then floors the yield.

``maximum_number_of_assets`` (default 100, at most 500) keeps the largest by
market cap, or under a tilt the top scores, ties larger first. The largest N are
this cap with no tilt, not a size tilt.

``company_exclude`` (names, exact, all listings) and ``theme_exclude`` (theme
codes) drop those companies, ``asset_ids`` included; matches are reported.

``construction``: 'market_cap' (by size, within the caps), 'equal' (ignores per-stock risk),
'min_risk' (lowest volatility) or 'risk_parity' (default). Caps bind every method.
``max_stock_weight`` is 10% by default; N names need 1/N, so a thin theme needs
more (1: no cap). Relaxed caps and unbuilt dates: ``notes`` (backtest's for past ones).

The weights are one solve for today. ``backtest=True`` also queues the history
backtest, which writes the ledger; follow ``backtest_key``.

Inputs: name, sizes, themes, regions, +22 more.

delete_portfolioDelete a portfolioA
DestructiveIdempotent
Inspect

Delete a strategy or an account the client owns. Permanent and cannot be undone.

Name what will be deleted to the client and get their confirmation first.
What goes depends on the id. A strategy is removed. An account is removed with
its positions, history and attached documents, and any bank link is dropped.
Catalogue strategies, and the people or households above an account, are
refused. Returns a confirmation only; ``list_portfolios`` shows the updated list.

Inputs: confirm (required), portfolio_id (required).

delete_simulationDelete a simulationA
DestructiveIdempotent
Inspect

Delete saved simulations from one account. Permanent and cannot be undone.

Name the simulations to the client and get their confirmation first.
``account_id`` is the account they are on, as ``list_simulations`` shows it;
simulation ids are numbered per account. If any id is not on the account,
nothing is deleted. Removes simulations saved here or in the web app. The
account's holdings are not touched.

Inputs: confirm (required), account_id (required), simulation_ids (required).

describe_assetsDescribe instrumentsA
Read-onlyIdempotent
Inspect

What instruments are and how they have done: one id, or up to 500. Draws nothing.

By id from ``find_assets``: equities, ETFs, funds and bonds, in the client's
currency. ONE id gives the full description: return, annualised return,
volatility and maximum drawdown over the standard windows, the six factor tilts,
a few company fundamentals and a fund's largest holdings. ``series_in_context``
adds the points of its curve.

SEVERAL ids, such as a screen's companies, give one line each: 1Y return,
volatility and maximum drawdown, 3Y annualised return, P/E, dividend yield and
market cap. ``fields`` adds groups: 'classification' (ISIN, GICS industry, size
segment, themes), 'valuation' (P/B, P/S, EV/market cap), 'quality' (ROE, ROA),
'growth' (the screener's growth score and its parts), 'factors' (the tilts) and
'esg' (score and exclusion). Ask only for the groups the question needs; one id
always gets the full description.

A figure that is unknown is left out, never given as zero, and the note says why.
``open_dashboard`` shows instruments to the client.

Inputs: asset_ids (required), fields, series_in_context.

describe_build_optionsHow to build a portfolioA
Read-onlyIdempotent
Inspect

How to build a portfolio or strategy with Analyzera, and which tools each way uses.

For a portfolio on a theme or sector (AI, cybersecurity, defence, energy) or on
any other screen.

'build_portfolio': a ready-made catalogue strategy (``find_portfolios``), the
strategy builder (``build_equity_strategy``, ``build_allocation_strategy``), the
stock screener and weightings (``screen_equities``, ``solve_equity_weights``), or
the fund screener and weightings (``screen_funds``, ``solve_allocation_weights``);
and common shapes of an allocation (equity and bonds, risk balanced, core and
satellite, target date). 'working_rules': saving, backtests, ids and how results
are reported. The same guidance as the server instructions, for hosts that do not
show them. Reference text; reads no account data.

Inputs: topic.

describe_card_screenWhat the screener card showsA
Read-onlyIdempotent
Inspect

The list last screened in the card a screen_equities card_ref names, re-run now.

For when the client says they re-screened or asks what the card shows. A card's
list replaces the one in the conversation once the card sends it to the chat
("Use the list from the screener card").

Inputs: card_ref (required).

describe_driftMeasure driftA
Read-onlyIdempotent
Inspect

How far an account has drifted from the strategy it tracks: active share and the largest gaps. Link a strategy first with assign_strategy.

Inputs: account_id (required). Returns: result

describe_historical_scenariosHistorical scenariosA
Read-onlyIdempotent
Inspect

How today's holdings would have fared in named past market episodes, as figures.

Replays the portfolio's current factor exposures through each episode's market moves:
the financial crisis, Covid, the 2022 rate rises and others since 2007, recoveries
included. With no selection every episode runs, worst first; ``tags`` picks episodes
by theme, ``scenarios`` by id, and either match counts. ``detail='full'`` adds each
episode's story, the main drivers and the currency effect. To compare, replay a
benchmark or another portfolio the same way.

A replay of the past, not a forecast: today's holdings, not what was held then, and
market-wide moves only. A one-sector what-if such as "technology down a fifth,
nothing else moving" is not an episode here; the sector weights from
``describe_portfolio_weights`` answer it.

Inputs: tags, detail, holdings, scenarios, +1 more.

describe_holdingsAnalyse holdingsA
Read-onlyIdempotent
Inspect

Risk, diversification, fundamentals and outlook for holdings given in the conversation. Nothing is stored. sections narrows the answer; 'weights' adds the breakdown.

Each line is an ``asset_id`` (as find_assets, screen_equities and the solve tools
return it), else an isin, ticker or name, or a ``cash_currency`` for cash, sized by
one of ``weight``, ``units`` or ``market_value``. Amounts and units mix freely;
weights cannot mix with either. A name that matches nothing close to it is
listed as not included rather than replaced by another company, and a name
matched to a differently spelt instrument is listed for checking.

Inputs: holdings (required), sections. Returns: result

describe_market_sensitivitiesMarket sensitivitiesA
Read-onlyIdempotent
Inspect

How exposed a strategy or account is to equity markets and to interest rates.

For "how exposed am I to rates / yields / the market" and for what-ifs. Each line
gives a beta and its impact: global equities (World Large Cap) and the client's home
market falling 10% (beta: % move per 1% market move), and yields rising 1 percentage
point on the home curve, on every curve at once and on each other currency's curve
(rate beta: % fall per point, the rate duration in years). Figures are linear, so
scale the beta for another shock: yields +3% is three times the +1% line, equities
-50% is beta times -50.

Every figure lets the other markets move with the driver using the latest
correlations between the risk factors, so shares have a rate figure too. This
assumes today's correlations; in large moves the correlations can change, and the
results with them.
Today's holdings, client currency, estimates not forecasts. For past episodes use
``describe_historical_scenarios``.

Inputs: holdings, portfolio_id.

describe_methodologyHow a figure is calculatedA
Read-onlyIdempotent
Inspect

How the figures another tool returns are calculated: the model, its main assumptions and why.

``tool_name`` is the tool whose figures are in question, such as
``describe_portfolio_risk`` for volatility and the risk level or
``describe_portfolio_outlook`` for expected return. The result is the same for
every caller and portfolio: topics in reading order, each with a summary and
sections. It describes how a model is built, not calibrated values, and reads no
account data.

Inputs: tool_name (required). Returns: object

describe_portfolio_fundamentalsSummarise factor tiltsA
Read-onlyIdempotent
Inspect

A strategy's factor tilts, and the dividend yield and P/E of its stocks.

Valuation, momentum, leverage, profitability, quality, risk, size and growth, each
-100 to +100 against the investable universe, 0 being its average. Quality is the
screener's: profitability and low leverage, averaged. Use it to check
that a build expresses the tilt it was asked for, or what a catalogue strategy
leans toward. A score is the axis, not a style: positive valuation means
expensive. Tilts describe the equity part only; ``coverage`` gives its share.
The risk tilt is how volatile the chosen companies' shares are, not the
portfolio's 0-10 risk level, which ``describe_portfolio_risk`` gives.

Inputs: holdings, portfolio_id.

describe_portfolio_outlookSummarise expected returnA
Read-onlyIdempotent
Inspect

A strategy's long-run expected return and what builds it, as figures with no widget.

For reasoning with the number, such as comparing two strategies or checking a
savings plan's required return. ``open_dashboard([portfolio_id], tab='outlook')``
shows the same figures with their build-up and disclosures.

The figure is a long-run average from a factor model: per annum, nominal (it
includes inflation) and BEFORE FEES: no fund charge, platform, custody or advice
fee is taken off it. It is not a forecast for any one year. The
ranges returned are part of the figure. Below the horizon floor stated in the
result the model has essentially no predictive power. ``coverage`` below 100%
means part of the strategy is not in the figure.

For a strategy with a glide path, ``glide`` adds the expected return year by year
along the path, over the whole path, and the yearly rates ``project_savings_plan``
takes as ``per_annum_by_year``.

Inputs: holdings, portfolio_id.

describe_portfolio_riskSummarise riskA
Read-onlyIdempotent
Inspect

How risky a strategy is, measured from what it holds today, as figures with no widget.

For comparing strategies or checking a level against a target.
``open_dashboard([portfolio_id], tab='risk')`` shows the same pane.

These are the risk model's view of today's holdings, not statistics of the track
record. Volatility is annualised and forward-looking. "Bad month" is the 1%
expected shortfall: the average of the worst outcomes, not a floor. The 0-10 risk
level is Analyzera's own scale, comparable only with other levels from this
platform; it is not the PRIIPs SRI, nor the risk tilt in
``describe_portfolio_fundamentals``. None of it is a suitability judgement.

``breakdown`` adds each part's share of the volatility, largest first: by holding,
by group, or by 'source' (market, countries and currencies, industries, style
factors, and what is specific to the holdings). 'factor' splits the style factors
into each one by name (valuation, momentum, size and the rest), beside the other
sources' totals.

Inputs: holdings, breakdown, portfolio_id.

describe_portfolio_seriesSummarise track recordA
Read-onlyIdempotent
Inspect

Summary statistics of a backtested strategy's track record, or an account's history.

A read: computes and writes nothing. Returns the summary statistics; the curve is
drawn by the card where the host renders one. ``series_in_context=True`` returns
every daily point, for questions about the curve's shape (peaks, time under water).

``contributions_by`` returns instead what each holding or group added to the
return between ``from_date`` and ``to_date`` (ISO dates; default the last year),
largest first. Contributions add up to the window's return. A fund counts as one
holding: its past holdings are not known, so it is not split by country, sector
or industry.

For a strategy it also gives the one-way turnover over the last year's worth of
rebalances and the dividend yield, gross: the track record deducts no trading
cost or withholding tax, and these are the inputs for estimating both.

For an account it is the account's own history. A strategy with no track record
yet is refused; ``run_strategy_backtest`` or a build with ``backtest=True``
creates one.

Inputs: strategy_id (required), to_date, from_date, contributions_by, +1 more.

describe_portfolio_weightsSummarise holdingsA
Read-onlyIdempotent
Inspect

What a strategy or account holds: the largest lines and the top of each breakdown.

A digest, not the full table: the largest holdings and the top rows by asset
class, asset type, country, sector and industry. Enough for "is it concentrated"
or "how much USA". ``open_dashboard([portfolio_id], tab='weights')`` shows the full
table.

The tail beyond the listed lines is not included. For an account, lines carry
amounts as well as weights, and funds may be looked through into their own
holdings, so a look-through holding count is not comparable with a direct one.
Weights marked as solved are what the strategy would hold, not published holdings.

Inputs: holdings, portfolio_id.

find_assetsFind an instrumentA
Read-onlyIdempotent
Inspect

Resolve instrument names, tickers or identifiers to the asset ids the builders take.

Each entry is one instrument, given by any codes known for it: ``name``, ``ticker``
in any common notation ('SHB B SS Equity', 'SHB-B.ST', 'STO:SHB-B', 'BRK.B'),
``isin``, ``cusip``, ``sedol``, ``figi``, or free text in ``query``, optionally with
the exchange or currency of the line meant. Entries may carry different codes. Each
code is resolved on its own and the answers are checked against each other. Up to 50
entries per call. Asset ids are dense, so an unverified id is usually a different,
real instrument.

Coverage differs by code. Tickers and names reach every traded line, and ISINs about
three in four. FIGIs are held for about one in five US listings and most ASX
listings, and almost none elsewhere. CUSIPs are held for about one in ten US
listings, and are also matched through their ISIN. SEDOLs are matched only through
UK and Irish ISINs. A FIGI, CUSIP or SEDOL on its own therefore often finds nothing;
with a ticker or ISIN in the same entry, that entry still resolves.

Each result has a status. 'exact': the query names one traded line. 'resolved': one
company or fund with several lines, of which one was chosen, in order: a line in the
client's currency that trades, an ordinary share over a receipt, the primary listing,
the most traded line; 'why' names the step. 'ambiguous': different instruments match
about equally well, the first being the most likely. 'not found'. Alternatives are the
same company's other lines (exchange, currency, share class, receipt) and other
instruments that also match, each with its id.

Only lines priced within the last two weeks match, so every id can be built with.
``ensure_price=false`` also matches delisted lines, marked 'no recent price', to look
up a company that no longer trades; a priced line is still preferred within a company.

Names match whole words and word starts, not descriptions ("Novo" matches, "the
Danish diabetes one" does not). Strategies and accounts are found with
``find_portfolios``.

Inputs: queries (required), kinds, ensure_price.

find_gicsFind GICS codesA
Read-onlyIdempotent
Inspect

GICS codes for the screener's industries: search by name ('banks'), or browse below a parent code. Neither lists the sectors and their groups.

Inputs: query, parent. Returns: result

find_portfoliosSearch strategies and accountsA
Read-onlyIdempotent
Inspect

Find strategies or accounts by what they are, without the whole list.

The lookup counterpart to ``list_portfolios``: narrows the same rows and draws
nothing. Suited to assembling an allocation from existing pieces ("the European
bond one", "something I built at around risk 5").

``query`` matches all of its words anywhere in a row, on the name and on the
row's facts (asset class, region, style, wrapper, owner), so "swedish equity"
finds "Sweden Large Cap". ``group`` is 'mine' (strategies this client built),
'analyzera' (provider catalogue) or 'accounts' (money the client holds; accounts
are not usable as build components). A risk bound keeps only rows with a risk
target, which means blends.

Returned strategy ids are ones this client may use as sleeves in
``build_allocation_strategy``. A result flagged as a partial match did not match
the whole query.

The catalogue holds factor styles (value, quality, momentum and others) side by
side and ranks none: Analyzera does not recommend either direction of any factor
tilt. A case for one is yours, from your own sources; the client chooses.

Inputs: group, limit, query, region, +5 more.

get_accessWhat this caller may doA
Read-onlyIdempotent
Inspect

The caller's plan, allowances remaining, currency and market.

Answers "what can I do here". Useful before a build or backtest, which each
spend a monthly allowance, and after a refusal that mentions a limit. It
counts as one call and spends no build or backtest allowance.

``excluded_tools`` lists tools this plan does not include; those are refused
regardless of arguments.
``counted: false`` on a meter means the counter could not be read and its
figures are unknown.

Inputs: person_id. Returns: The caller's plan, allowances and market, in one read.

get_alertsList alertsB
Read-onlyIdempotent
Inspect

Every alert this client has set.

Inputs: no named parameters. Returns: result

get_backtest_statusCheck a backtestA
Read-onlyIdempotent
Inspect

Whether a backtest started by run_strategy_backtest is queued, running, done or failed (state), with an ETA while it runs. Free to call. It waits up to 20s for a running backtest to finish before answering, so call it again rather than sleeping between calls.

Inputs: key (required). Returns: key, say, step, error, +8 more

get_default_instrumentsDefault instruments for a currencyA
Read-onlyIdempotent
Inspect

The client's currency and the default instruments a build resolves in it.

Shows which broad-equity, long-bond and short-bond instruments
``build_allocation_strategy`` uses for ``instrument='broad_equity' | 'long_bond' |
'short_bond'`` in this client's currency. Builds resolve these themselves; this
read is for when the client asks what they would hold.

``short_bond`` is a short-duration bond fund, not cash. ``caveat`` notes
currencies missing a leg: GBP has no sterling short-duration fund and borrows the
USD one. Each instrument's ``source_currency`` shows a borrowed leg, which adds
currency risk.

``disclaimer`` states that these are defaults, not a recommendation; the list
read without it looks like personal advice.

Inputs: no named parameters. Returns: object

get_risk_ceiling_for_horizonRisk ceiling for a horizonA
Read-onlyIdempotent
Inspect

The highest risk level a stated horizon supports, from Analyzera's published table.

For when the client says when they need the money and asks what risk level
fits. The result is a ceiling: the client may choose any level at or below it.
``digest`` carries the wording of the result and ``table`` the whole horizon
policy. It uses the same horizon-to-loss chain as the advice path.

``horizon_years`` is the horizon the client stated; nothing is read from their
profile or records. Band edges close at the top, so five years falls in the 3-5
band. ``max_monthly_loss`` (0.10 = 10%) can only lower the ceiling; with both,
the lower wins.

This is a calculator, not a suitability assessment: it does not consider the
client's appetite, capacity or experience, and records nothing.

Inputs: horizon_years (required), max_monthly_loss. Returns: object

get_strategy_definitionRead a strategy's definitionA
Read-onlyIdempotent
Inspect

The arguments that would rebuild a strategy: its screen, tilts, caps and items.

Call it before editing a strategy. The builders replace a definition rather than
patch it, so an edit restates every argument; this is where they come from,
including for strategies built in the web app. It returns what a strategy is made
of, not what it holds (that is the weights pane).

``not_expressible`` lists stored settings the builders have no argument for; a
strategy with any cannot be rewritten here without losing them. Catalogue
strategies can be read too; only rewriting requires ownership.

Inputs: strategy_id (required).

list_portfoliosList strategies and accountsA
Read-onlyIdempotent
Inspect

List everything the client can see, as rows.

Three groups: 'accounts' (money the client holds), 'mine' (strategies this client
built, here or in the web app) and 'analyzera' (the provider catalogue, narrowed
by the client's currency and jurisdiction). Accounts and own strategies come as
rows with their ids; the catalogue comes as counts per asset class, and
``find_portfolios`` searches it. A shortened catalogue carries ``shelf_note`` with
the reason. An account held at another institution carries ``held_elsewhere``,
with the ``source`` and ``account_ref`` that ``sync_external_account`` updates it by.

Draws nothing. ``open_dashboard`` shows the same list in the card.

Inputs: person_id.

list_rebalance_targetsList rebalance targetsA
Read-onlyIdempotent
Inspect

The target weights pre-rebalance notices have sent for a strategy, latest first, each labelled with its rebalance date. portfolio_id is a strategy, or an account, which reads the strategy it tracks (list_portfolios shows which). Weights only; none is readable before its 12:00 Stockholm release.

Inputs: portfolio_id (required), limit. Returns: result

list_sharesList share linksA
Read-onlyIdempotent
Inspect

Every live share link this client has made, newest first, with what each shows.

Inputs: no named parameters. Returns: The caller's live share links, newest first.

list_simulationsList saved simulationsA
Read-onlyIdempotent
Inspect

The saved simulations on an account and the accounts under it.

A simulation is a set of trades on one account's holdings, saved in the
Analyzera web app or with ``save_simulation``. Only one with status 'executed'
has results; pass it with its account to ``open_dashboard`` to compare
with and without it. Strategies have no simulations.

Inputs: portfolio_id (required).

open_dashboardOpen the dashboardA
Read-onlyIdempotent
Inspect

Open the dashboard card on accounts, strategies, funds or stocks, with tabs.

The one tool that draws a card for them. ``describe_assets`` and the
``describe_*``, ``list_*`` and ``find_*`` reads return figures without one.

``ids`` opens on the first; several are a shortlist the client flips between
in the card. Accounts, strategies and instruments from ``find_assets`` mix
freely. Omitted, the card opens on Home, with the client's list beside it.
``tab`` opens on that tab ('returns', 'weights', 'risk', 'fundamentals',
'outlook' or 'construction': how a strategy is built); omitted, 'returns'
('weights' before a backtest). A fund or ETF has every tab but 'construction';
any other instrument has 'returns', 'risk' and 'fundamentals' only.
``compare_id`` puts another strategy, account or market benchmark beside the
first id on every tab: use it whenever the client asks to compare, put side by
side, or measure one against another. Returns figures cover the first id's
history, and the comparison's are given only for periods its own record fully
covers. Instruments are compared with ``describe_assets``.
``simulations`` are saved simulations from ``list_simulations`` or
``save_simulation``, selected in the card's comparison instead, so every tab
except returns shows the first id beside itself with them applied. Each is on
that account or one under it, such as everything the client holds, and an
account takes at most one.

Returns a digest of the first id's opened tab; with ``compare_id``, both sides'
holdings, risk, outlook and track records; with simulations, the tab measured
with them applied. On a strategy whose backtest ``get_backtest_status`` reports
done, tab 'returns' shows the finished record.

Inputs: ids, tab, person_id, compare_id, +1 more.

preview_simulationPreview changes to an accountA
Read-onlyIdempotent
Inspect

Measure an account as it is and after changes, without saving anything.

Answers which way the client's position would move, and by how much. The account
is measured twice through the Risk tab's own pane. ``save_simulation`` takes the
same changes and saves them for the dashboard to compare.

One form per call. ``strategy_id`` + ``amount`` buys a strategy. ``changes`` are
several signed changes at once (a switch is a negative amount on an account plus
an equal positive one; an account cannot be reduced below what it holds). A
change with ``asset_id`` is one instrument: "sell 20,000 of Volvo in the ISK and
buy Investor" is ``{id: ISK, asset_id: Volvo, amount: -20000}`` plus
``{asset_id: Investor, amount: 20000}`` with ``account_id: ISK``; for a switch
between instruments that names one account, that account is the default.
``weights`` with ``account_id`` reweights one account at its current value: each
weight is an instrument's share of it, and held instruments left out are sold.
Weights adding up to 1 stay fully invested; less holds the rest as cash; more,
up to 2, borrows the excess as cash. Instrument weights from
``solve_equity_weights`` or ``solve_allocation_weights`` fit as they are.
Otherwise ``account_id`` defaults to everything the client holds, or everything
one client holds with ``person_id``. An empty account is valid for the first two
forms: the before side is empty.

Nothing is written. There is no track record for a simulation and the returns
tab is unavailable for it. The result is a measurement, not a suitability
judgement; the client's own limits are not read.

Inputs: amount, changes, weights, person_id, +2 more.

project_savings_planProject a savings planA
Read-onlyIdempotent
Inspect

What "X up front and Y a month for Z years" grows to, and how much of it is growth.

Handles the plan arithmetic that a lump-sum calculation gets wrong: only the
opening amount is invested for the whole span. The house conventions for timing
and compounding are fixed here.

Returns the central figure at the supplied rate and ``total_contributed``. No
range is returned: the outlook's band is stated at the model's horizon and does
not transfer to a plan's shorter dispersion horizon. ``dispersion_horizon_years``
under about ten means the figure is arithmetic at an assumed rate rather than an
expectation. No client profile is read.

``per_annum_by_year`` replaces ``per_annum`` with one rate per year, such as the
glide path rates ``describe_portfolio_outlook`` returns for a strategy with a
target date; ``per_annum`` in the result is then the constant rate that ends this
plan at the same value.

Inputs: years (required), cadence, per_annum, contribution, +2 more. Returns: A contribution plan measured at one stated rate.

revoke_shareRevoke share linksB
DestructiveIdempotent
Inspect

Turn off one share link by its token from list_shares, or every link showing portfolio_id. A revoked link shows that it was turned off.

Inputs: token, portfolio_id. Returns: say, revoked

run_strategy_backtestRun a backtestA
DestructiveIdempotent
Inspect

Start a backtest of a strategy the client built, and return its key at once.

Writes: the backtest publishes the strategy's holdings and transaction ledger.
Takes a minute or two; returns a ``key`` and an ETA, and ``get_backtest_status(key)``
(free) follows it. Each run spends the backtest allowance, except that the same
definition on the same day reuses the earlier run. The window is the history the
strategy was built with, 5 years by default; ``history_years`` first moves the
strategy's start (back to 2006 at most) and backtests over the new window,
leaving the definition as it is. For a strategy already backtested,
``describe_portfolio_series`` reads the result.

A strategy on a fixed list (``asset_ids``) holds that list through its whole
history, so a list picked today, from a screen or from today's holdings, has
hindsight bias in its backtest; a screened strategy picks its names as of each date.

Inputs: strategy_id (required), history_years.

save_simulationSave a simulation on an accountA
Idempotent
Inspect

Save changes to one account as a simulation that the dashboard can compare against.

Takes what ``preview_simulation`` takes, on one account: ``strategy_id`` +
``amount``, ``changes``, or ``weights``. Sales and resizes must be on
``account_id``, and purchases land in it. The saved holdings are the account's
own plus the changes as of the latest price date, with no optimisation, so they
measure what the preview measured.

Returns the simulation id and the same before/after measurement as
``preview_simulation``. ``open_dashboard`` takes it in
``simulations``, on the account or on any node above it, alongside other
accounts' simulations. It also shows in the web app. A name already on the account is
refused; ``delete_simulation`` removes simulations.

Inputs: name (required), account_id (required), amount, changes, +2 more.

screen_equitiesScreen stocksA
Read-onlyIdempotent
Inspect

Screen stocks by hand: list the companies that pass a screen, unweighted and unsaved.

For exploring stocks before anything is saved. The ways to build a portfolio,
including when the screener is one of them, are in ``describe_build_options``;
a ready-made strategy on a theme or sector is found with ``find_portfolios``.

Each company comes with its country, sector and, under a factor tilt, the score
it was ranked on (its fit to the tilts) and each factor on its own axis.
Factors are axes, not styles: valuation high is expensive and low is cheap
('value'); size low is small caps ('size'); for quality pass the one factor
'quality', which splits its share between its parts. ``maximum_number_of_assets`` keeps
the largest by market cap; a size tilt scores every large cap the same. A
company with several share classes is listed once, by its most traded line,
unless ``asset_ids`` names the classes. ``request`` echoes the arguments, which
``solve_equity_weights`` and ``build_equity_strategy`` take unchanged; a strategy
built from them re-runs the screen at every rebalance. The listed ids are this
date's selection only. Where a card is drawn it lists every company that passed,
so one screen is one call.

``sizes`` defaults to large and mid; a theme usually needs small caps too, and
micro caps where that finds nothing. An empty theme screen says whether the
region has no members at any size. The funnel says how many names each stage
kept. ``date`` screens as of a past date; data before 2022 is sparse enough to
reorder a universe, and nothing can be screened before 2005, or with micro caps
before 2021-01-29.

Inputs: date, sizes, themes, regions, +11 more.

screen_fundsScreen fundsA
Read-onlyIdempotent
Inspect

Screen funds and ETFs: the funds that pass a screen, one line each, unweighted and unsaved.

One named fund is found with find_assets; stocks with screen_equities. The listed
asset_ids are the items solve_allocation_weights and build_allocation_strategy take.

Where a card is drawn, the client can also add any fund to its shortlist by name or
ISIN, open a fund's details and set another fund beside it there. To compare funds
the client names, open them with open_dashboard instead.

Labels classify each fund's mandate; a label a fund type lacks screens that type
out. A platform in ``fund_lists`` also passes EEA-domiciled ETFs where it is a
broker; an own list alone lists its funds with their figures. The result names the
fund lists this client can use. Fees are the ongoing charge (OCF/TER), percent a
year. Each fund's risk level places its volatility on the platform's 0-10 scale.
Volatility and returns are percent in the client's currency; 3y and 5y returns are
annualised
and need that much price history. An unknown figure fails a limit set on it. A
fund's share classes fold into one line: the class in the client's currency, else
the cheapest. The 0-10 rating ranks a fund within its peer group on five-year
risk-adjusted return after fees; it does not compare segments.

Inputs: coins, sizes, search, styles, +21 more.

send_feedbackSend feedback to the Analyzera teamAInspect

Send the Analyzera team a bug report or feature request, by email.

The text is sent as written, with the sender recorded automatically. Returns a reference for the report.

Inputs: message (required), category, person_id, tool_name, +1 more. Returns: reference

set_alertsSet alertsA
DestructiveIdempotent
Inspect

Email alerts, as one daily digest, on a strategy ('rebalance', 'risk') or an account ('risk', 'drift' from the strategy it tracks). Replaces the kinds set on that subject; [] turns them off. threshold: a risk-level step (default 0.5) or a drift share (default 0.05).

'pre_rebalance' on a strategy emails its next target weights from 12:00 Stockholm
on the weekday before it trades. A linked account gets it without asking; leaving
it out of ``kinds`` turns it off.

Inputs: kinds (required), subject_id (required), threshold. Returns: result

set_fund_listSave a fund listA
DestructiveIdempotent
Inspect

Save the client's own list of funds under name, such as the funds an advisor works with. Replaces a list of the same name (any case); an empty asset_ids deletes it.

Funds and ETFs only, by asset_id from screen_funds or find_assets. screen_funds takes
the list by name in ``fund_lists``, to screen within it or list its funds.

Inputs: name (required), asset_ids (required).

share_viewShare a viewA
Idempotent
Inspect

A public link to one card view, for WhatsApp, SMS, mail or Slack.

``kind`` picks what it shows:
- ``portfolio``: one dashboard tab (default 'returns') of strategy or account
  ``portfolio_id``. ``compare_id`` draws a market benchmark or another strategy
  beside it; ``lookthrough`` shows holdings with funds resolved. ``all_tabs`` shares
  every tab and ``allow_copy`` lets the viewer copy a strategy the client owns into
  their own account; both are on unless the client asks for one tab or no copying.
- ``comparison``: ``portfolio_id`` with ``against_id`` beside it, as
  ``open_dashboard`` with ``compare_id`` draws them.
- ``instruments``: one of ``asset_ids`` opens that instrument's page on ``tab``
  ('performance', 'holdings', 'tilts', 'fundamentals' or 'risk'; default
  'performance'); several open a table of the headline figures ``describe_assets``
  gives.

The link opens the card fixed on that view, read-only, with live figures in weights
and percentages only, never values, amounts or units. The viewer cannot change the
client's account; a copy is the viewer's own. The same view reuses its link;
``revoke_share`` turns it off.

Inputs: kind (required), tab, all_tabs, asset_ids, +5 more. Returns: The link a share call made or reused.

solve_allocation_weightsWeight a multi-asset allocationA
Idempotent
Inspect

Weight a mix of instruments and strategies on one date, without saving it.

The ad hoc form of ``build_allocation_strategy``: the same arguments and defaults,
solved once instead of saved.

Returns each item's weight and risk contribution, the volatility reached against
the target, and the looked-through instruments. ``request`` plus a name is the
``build_allocation_strategy`` call that saves it; the looked-through ids and
weights, passed as ``holdings``, are what the ``describe_portfolio_*`` reads
measure unsaved. A strategy item the client
owns that holds nothing yet has its holdings published first, as a build does;
``writes`` says so. With ``glide_target_date`` the weights are those of the level in
force today, and ``glide`` is the schedule. ``signal`` scores show on each item.

Inputs: items (required), date, signal, risk_level, +9 more.

solve_equity_weightsWeight a stock screen or listA
Read-onlyIdempotent
Inspect

Weight a single-stock portfolio on one date, without saving anything.

The ad hoc form of ``build_equity_strategy``: the same universe and construction
arguments with the same defaults, solved once instead of saved, so the weights
are the ones that build would hold today. Screen live (the ``request``
``screen_equities`` echoed) or pin ``asset_ids``, a list the client brings. The
caps bind every method, 10% per stock unless given, as in the build; N names need
a cap of at least 1/N. A relaxed cap is reported in ``notes``, as is what a
liquidity limit (``assumed_aum_usd``) zeroed or relaxed.

Names asked for that hold no weight are listed in ``unweighted``. ``request``
plus a name is the ``build_equity_strategy`` call that saves it, re-screened at
every rebalance; the weighted ids are today's picks, and saved as ``asset_ids``
they give a backtest hindsight bias. The asset ids
and weights, passed as ``holdings``, are what the ``describe_portfolio_*`` reads
measure unsaved. One date (``date``, default the latest), so no track record.
Funds and ETFs are weighted with ``solve_allocation_weights``. A themed screen
also names any catalogue strategy on the same theme, as an alternative to saving.
Where a card is drawn it lists every holding, so one weighting is one call.

Inputs: date, sizes, themes, regions, +17 more.

solve_savings_planWhat a savings target takesA
Read-onlyIdempotent
Inspect

What it takes to reach a target: the return needed, or the saving needed.

Returns ``required_per_annum`` (the rate that reaches the target as stated), and
``required_contribution`` and ``required_initial`` (the two saving levers, each
at the supplied rate). A required return says what the target demands, not how
likely it is; ``describe_portfolio_outlook`` gives a strategy's expected return
for comparison.

A negative ``required_per_annum`` means deposits alone overshoot the target. A
negative ``required_contribution`` means no monthly saving is needed.
``required_per_annum: null`` means no rate in the solver's range reaches the target.
``per_annum_by_year`` (a glide path's rates) can stand in for ``per_annum`` when
the saving levers are solved.

Inputs: years (required), target_value (required), cadence, per_annum, +3 more. Returns: What it takes to land a plan on a target.

sync_external_accountUpdate an account held elsewhereA
DestructiveIdempotent
Inspect

Create or update the client's own account held elsewhere, from a full snapshot. Writes.

For holdings at a bank or broker, not strategies, read from a screenshot or from
the bank's or broker's own MCP connector.

A new ``(source, account_ref)`` creates an account; a known one is made to match.
Update an account with the pair from its ``held_elsewhere`` in list_portfolios.
``holdings`` is the whole account: a holding left out is set to zero, so a source
that only reports changes cannot use this tool.

Size each line with ``units`` or ``market_value`` plus ``currency``; identify it
by ``isin`` (most reliable), ``ticker`` or ``name``. Cash is a line with
``cash_currency`` and no identifier. Market values convert at Analyzera's price.

The account counts toward wealth and concentration, cannot be traded here and
does not refresh itself. Instruments not carried are listed in ``unmatched`` and
excluded, so ``imported_value`` can be below the source's.

Inputs: source (required), holdings (required), account_ref (required), as_of, +3 more. Returns: What the account holds now, and what did not make it.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      C
      maintenance
      Provides tools to research crypto trading strategies via backtesting, walk-forward validation, and paper trading, with a deflated-Sharpe overfitting check. Enables natural-language-driven analysis and interpretation of strategy performance.
      2
      Apache 2.0
    • F
      license
      Not graded
      quality
      B
      maintenance
      Enables deterministic financial research by retrieving price history, calculating risk metrics such as Sharpe ratio and drawdown, and generating cited, provenance-aware reports.
      -
    • A
      license
      A
      quality
      D
      maintenance
      Enables AI assistants to backtest trading strategies described in plain English, providing access to market data, technical indicators, and comprehensive performance reports.
      13
      1
      MIT
    • A
      license
      Not graded
      quality
      D
      maintenance
      Local-first backtesting engine with built-in overfitting detection (PBO, deflated Sharpe, bootstrap CI, walk-forward) and a native MCP server for AI agents to validate trading strategies.
      4
      Apache 2.0
    Try in Browser

    Glama MCP Gateway

    Add one secure layer between your agents and this server.

    Resources