Priorcase

Read what every asset was doing at the same moment, side by side: the close, the day and three-day returns, the shape of the move before it and the path after, for each one. Reach for it when the question is about the surroundings of a moment rather than the one asset — what the dollar, the yields and oil were doing while bitcoin did that. For one asset at one moment in more detail, use get_market_state. `at` takes up to 24 UTC ISO-8601 moments and every asset is read at each of them, so one call compares moments as well as assets. Everything reported was knowable at that moment. `window_minutes` is how far back each shape reaches and `after_minutes` how far past the moment it runs; left out, they take the same defaults the searches draw at.

Find the past moments whose price shape most resembles a given one, each with the path that followed it. Reach for this when what you hold is a moment and what you want is other moments shaped like it. If what you hold is a condition you can state, use query_history; if it is a kind of recurring event, use get_topic_outcomes; if you already have the moments and only want their paths drawn together, use get_price_paths. Matching is done by a model of ours: it reads the shape of the move before a moment rather than its level, so a quiet stretch can match a violent one and two moments thousands of dollars apart can be alike. Matches come back one by one and are never averaged; the spread between them is the answer. Each is point-in-time — what it reports was knowable at that moment, and what came after is labelled as having followed. Read the `quality` field before reading anything into the set. `asset` takes a symbol from list_coverage. `at` is a UTC ISO-8601 moment inside that asset's range; omit it to search from now. `k` is how many moments come back, and a call costs one answer for every ten of them. `scale` only sets the window the paths are drawn at — it does not change which moments are found. An asset kept at one value a day — list_coverage's `searched` says which — is matched and drawn on that one value, so the path after a moment is a bar or two rather than a curve and `quality.range_median_pct` comes back near zero. Read it before making anything of such a set.

Get the bars themselves — open, high, low, close and volume at a fixed step — for a stretch of time. Reach for it when the tools above do not shape the data the way you need it: your own measure, your own chart, a window none of them draw. For a moment read against its own history, use get_market_state; for the path around moments as percent from each, use get_price_paths, which is what the searches compare on. `asset` takes a symbol from list_coverage and `step` one of its scales — an asset kept at one value a day has only `1d`. `since` and `until` are UTC ISO-8601 bounds; left out, the whole history at that step comes back, and a stretch too long to serve is refused in those words rather than truncated quietly, so narrow it or take a longer step. BTC at `1d` is about five thousand bars and comes back whole; BTC at `1h` needs a `since`. Nothing later than the end of the data is returned, so a window running into the present ends where the data does.

Read what the market was at one moment and what happened after it: returns over 1h, 24h, 7d and 30d, the day's high, low and volume, how volatile it was against its own month, and the drawdown from the week's high. Use this for one moment's numbers; for the price path around a moment, or around several at once, use get_price_paths. Everything under `then` was already knowable at that moment — nothing later leaks into it — and what followed is labelled as having followed. `at` is a UTC ISO-8601 moment inside the asset's range, which list_coverage gives. One call costs one answer.

Draw the price path around one or more moments, as percent from the close at each, so paths of different sizes can be laid over one another. Reach for it when you already hold the moments — from any of the searches — and want their paths side by side. For one moment's summary numbers, use get_market_state; to find the moments in the first place, use find_analogs, query_history or get_topic_outcomes. Offsets are minutes from that moment: negative before it, positive after. A moment still inside the present has no `after`. `at` takes up to 24 UTC ISO-8601 moments in one call. `scale` sets how far back each path reaches, `after_minutes` how far past each moment it reads. `asset` takes a symbol from list_coverage.

Start here. Returns what this server answers and which tool answers which question — find_analogs for a moment, get_topic_outcomes for a kind of recurring event, query_history for a condition, get_market_state for one moment, get_price_paths to draw them together — what the two rules mean for how you read any reply, and what can be asked without a key. It carries the live coverage that list_coverage returns, so one call is enough to begin. Takes no arguments and costs nothing.

List every past event of one kind — every CPI release, every FOMC statement — each with what was knowable at that moment and the path that followed it. This is the tool for 'what happened the last N times this happened'. Reach for it when what you hold is a kind of event rather than a moment or a condition. Take `topic` from list_topics; for one dated event on its own, use list_events. Newest first. Pass `alike` — a UTC ISO-8601 moment, or 'now' — to rank that same list by how much each one resembled that moment instead, so 'of every past FOMC, the ones that looked like now' is one call; each item then carries that number, measured by the same model find_analogs uses. Outcomes come back one by one and are never averaged, and every member of the kind stays in the list even when it cannot be ranked. `asset` takes a symbol from list_coverage.

List what this server can answer about: every asset with the name and aliases it answers to, where its data comes from, the first moment held and how far each scale reaches; the scales themselves; and the condition phrasings query_history reads. Call this before guessing a symbol, a scale, a date range or a phrasing — the other tools refuse what falls outside it, and the aliases are how 'bitcoin' or 'xbt' becomes a symbol. For the kinds of recurring event the data is indexed by, use list_topics instead. Takes no arguments. One call costs one answer.

List dated events the data is indexed by — CPI releases, FOMC statements, options expiries — each with the moment it became known, the source it is taken from and the topics it belongs to. Use this to find or date a single event; for every event of a kind together with what followed each, use get_topic_outcomes. By default it lists events already known, newest first. Set `upcoming` to list what is scheduled ahead instead, soonest first and counted from the end of the data: a calendar is public in advance but what a release will say is not, so an event still ahead carries only its kind — that an FOMC statement is due, not what it will decide. `q` matches words in the name or aliases, `kind` is one of fomc, cpi, crypto, macro or market, and `since`/`until` bound when an event became known. `days` applies only when `upcoming` is set. One call costs one answer.

List the kinds of recurring event the data is indexed by — CPI releases, FOMC statements, rate cuts and holds, halvings, exchange failures — each with its slug and how many of them are held. Use this to find the slug for get_topic_outcomes; for a single dated event rather than a kind, use list_events, and for a moment that is not an event at all, use find_analogs or query_history. `q` narrows the list to labels carrying those words; omit it for all of them. One call costs one answer.

Find every past moment a condition was true, newest first, each with what was knowable then and the path that followed. Reach for this when the condition can be stated; to search by the shape of the move instead, use find_analogs. A condition is one fact the bars can answer, written in words: the price level ('under 100k', 'above 7,000'), a move over an hour, a day or three days ('fell 10% in a day', 'rose 5% in an hour'), how far below the 7-day high ('20% below its high'), or how loud the day was against its month ('this volatile', 'quiet'). 'crashed' and 'rallied' are read as a 10% day. The wording around those facts is free; the facts are not — anything else comes back refused with the list rather than guessed at, and list_coverage carries the same list. The response carries how the condition was understood, so the reading can be checked before the moments are trusted. A run of bars that all meet the condition counts once, at the first, and every value is measured on bars that had closed by that moment. `asset` takes a symbol from list_coverage. A call costs one answer for every ten moments.