GammaRips Options Intelligence
Could use "Primitivas de inteligencia de flujo de opciones" maybe the original has "Options-flow intelligence primitives for AI agent", i.e., "primitives" is emphasized. We can translate "Primitivas de inteligencia..." But let's be faithful: "Primitivas de inteligencia de flujo de opciones para agentes de IA." The original emphasized the word "primitivas" as a concept. Actually the original: "Options-flow intelligence primitives for AI agents." So the bold is on "primitives", not "options". So translation: "Inteligencia de flujo de opciones primitivas para agentes de IA." Yes.
Better: "Primitivas** de inteligencia de flujo de opciones para agentes de IA." That matches. Actually "primitives" is the noun, "Options-flow intelligence" is an adjective noun phrase. In translation, "Primitivas de inteligencia de flujo de opciones" is fine.
Now, the paragraph: "Every trading morning GammaRips scans the US options market for unusual institutional activity and curates it hard — down to a ~50-name high-signal BULLISH pool."
Spanish: "Cada mañana operativa, GammaRips escanea el mercado de opciones de EE.UU. en busca de actividad inusual institucional y lo selecciona con rigor — hasta reducirla a una cartera de ~50 nombres con una señal alta de BULLISH."
Then "This MCP server gives a bring-your-own-agent trader that pool plus the substrate to reason over it: point-in-time features, realized opportunity surfaces ..."
"Este servidor MCP ofrece a un trader que trae su propio agente ese conjunto, más el sustrato para razonar sobre él: características en un point-in-time, superficies de oportunidad realizadas (excursiones máx-favorables / máx-desfavorables sin salida aplicada), etiquetas de resultado, contexto de régimen y manuales metodológicos."
"bracket" should be "bracket"? Could use "bracket" but no need. The source: "bracket outcome label". I'll translate "etiquets de resultado de tipo arquetobracket" maybe. But "bracket" in finance is a profit target. But not of exact translation. Let's retain "bracket" as a term. So: "etiquetas de resultado de branket" e.g.
"point-in-time features" keep as "features at point-in-time"? Or "atributos a un punto en el tiempo". Better "características a vencimiento point-in-time". Actually "point-in-time" is a concept: "características tomadas en cada punto temporal". Let's use "características de un punto en el tiempo".
"regime context" "contexto de Regímen".
Then "y metodología guías" "and methodologyen playbooks" -> "libros de metodoología" perhaps. The source says "methodology playbooks". Use "manuales de metodologías".
Then blockquote: "Design principle: primitives, never un" etc.
"Principio de diseño: primitivas, "nun" quote.
Let's go with:
"Principio de diseño: primitivas, nunca una selección. No hour no *
" Cada agente reasons from mismo "contrato" contractual.
"paper-traded research data" -> "datos de investigación simüelada sobre trrading (papeles)" allocate.
"educational only; not in investment advice" -> "con fin educativo", "no es asesoramient de inversiones".
Then heading.
"# Endpoint MCP alojado" good.
Map:
Endpoint MCP alojado
Streamable HTTP (principal):
https://mcp.gammarips.com/mcpSSE (heredado, en ventana de desuso):
https://mcp.gammarips.com/sseJSON-RPC sin estado:
https://mcp.gammarips.com/jsonrpcTararjeta de servidor:
https://mcp.gammarips.com/.well-known/mcp/server-card.jsonEndpoint OAuth (clientes de chat):
https://mcp.gammarips.com/pro. Mismo servidor, mismas 9 herramientas, but requires a credential; thus ChatGPT, Claude, etc. We can translate: "Mismo servidor, mismas 9 herramientas, pero requiere una credencial, así que ChatGPT, Claude (claude.ai / Desktop), Cursor y cualquier cliente MCP que hable OAuth 2.1 ofrece a tu inicio de sesión simultaneously". Better: "te ofrece un inicio de saatto de GammaRips` when you add it.
Let's compose:
... ... Mismo serer, 9 tools, but require a credential, by lo que ChatGPT, Claude (claude.ai / Desktop), Cursor and any MCP client that speak OAuth 2.1 offers he una GammaRips sign-in cuando lo add. Tu plan de suscripción viaja in the token.
Then:
Descubrimiento: /.well-known/oauth-protected-resource/pro; authorization server: https://gammarips.com.
Then auth:
Autenticación: dos credenciales, un solo nivel. (1) Clave API:
gr_live_...comoAuthorization: Bearer <clave>(orX-API-Key) para clients that can send an actual dynamically set header. (2) Token de acceso OAuth 2.1, auto regenerated, for chat clients etc. Free-tier works.
"Enforce is live." -> "Enforce está activo."
"Get access at..."-> "Consigue acceso en gammarips.com/pricing."
Now "Herramientas disponibles (9)" translation.
"V4 (2026-07-17) redujo the 29 tool surface to 9. " Podemos: "V4 (2026-07-17) consolidó la superficie de 29 herramientas V3" etc. "las herramientas absorbidas hoyon como modos view= / granularity= de these 9." "web_search fue eliminada."
Then free tier list.
"Free tier" translate "Nivel gratuito". "Pro tier" -> "Nivel Pro".
We should keep "Agent Access, $39/mo key" maybe "Acceso Agent" but it's a product name? Actually "Agent Access" is a product tier. Keep "Agent Access" as is? It is a subscription name. The instructions say "Product names" are verbatim. So "Agent Access" should remain. Hmm. But translations may render "Acceso para agentes"? However since it is possibly a name/menu, "Agent Access" is a prepayment: "Agent Access". I'd use "Agent Access" verbatim. But "Pro tier (Agent Access, $39/mo)" -> "Nivel Pro (Agent Access, $39/mo)". That makes sense.
"Pro tier (Agent Access, $39/mo cred)" -> "Nivel Pro (Agent Access, clave de $39/mo)". It's fine.
Then bullets:
get_pool(free) — trans: "(gratis)"."candidate pool" = "grupo de candidatos", "universo de candidatos".
The paragraph with modes: "vista \"enriched\" (narrativa depurada/ técnica/contrato/mom_60, vista a salvo de fugas; predeterminada), \"raw\" (escaneo pre-curad), \"features\" (vecto caracter a eva muestra), \"preview\" (adelanto público)."
"get_signal": "(pro)** — un ticker:
view=\"detail\"(todo el enrich, predef) oview=\"earnings\"(the doctrine earnings-window check).""get_liquidity": "(pro)** — liquidez nueva para ese día: un único
contract(primera caché,live=trueto force), ..."Q query_outcomes" long.
Long bullet. We translate carefully:
* **+cmd`** paper": In original:
"* query_outcomes (pro) — the outcomes + receipts substrate, via view=:
labels (row-level bracket labels + features; default), summary (...)
We need preserve indentation and newlines.
Translate:
query_outcomes (pro): el sustrato de outcomes + recibos, a todo via view=:
labels (etiquetas de branket a nível de fil + características; predeterminado), summary (agregaciones agrupadas), surface (excursions MFE/MAE por contrato, sin excurs - aggregate_only=True gives MFE/MA quantiles over la ventana ENTERA y es el mode for exit, since row mode cape at 200 and truncated/matched_rows/partial_scan_date; harvest (curva de l probability de toque), exit_rule (puntúa a rule), signal_performance / win_rate (dirección del subyacente, NO G&L de opciones), positions / performance (realized paper trading).
"pair V7_1_TILTED_GIGO and entry on/after ..."
I'll translate elegantly:
"La cohorte viva es el par V7_1_TILTED_GIGO y la entrada en/fecha de cohort_start (2026-08-10), que los respuestas ahora llevan incras —. La etiqueta de pólitica ALONE no defines la cohorte, porque el ledger del commerce conserves the cohortes descartadas under esa mism etiqueta. Justo despu de un re, the cohort liva legítim is an empty: total_trades: 0 with null ... means "aún no ha acumulado closed trades", NOT "a win rate of 0%". policy_version=\"all\" reaches every operation but includes, engine has disowned — not a track record."
This is length but fine.
Need to preserve truncated etc.
Then replay_contract (pro) — cinta de precios rápido for own exit rule: granularity="minute" (minute path+ exact first crossing; default) or "day" (daily OHLCV marks series). This server no simulates exits.
get_... etc.
Need translate "This server does not simulate exits." original "This server does not simulate exits." So "Este servidor no simula salidas." Good.
But from original list of tools: replay_contract (pro) — "raw price tape for your own exit rule" etc. "This server does not simulate exits." So repeat.
Then free line:
get_regime_context (gratis) — context as of date + "the fail-closed regime interpretation".
get_market_calendar_status (gratis) — view=status (NYSE open/close, by def) or view=scan_dates (which scan dates have data).
get_playbook (gratis) — method + reference: no absolute: catalog; name= fetch a playbook (..., ...) or name="schema" machine-readable data contract (per-column leak classification); field= expla any signal field (det, no LLM). Playbooks are also MCP resources (`gam green etc.)".
get_daily_report (gratis) — view="report" (complete daily report, detault) or view="list" (recent reports).
Removed
Need to translate "### Removed" as "### Eliminados".
Then text:
web_search (V4). The engine's daily select... no se publica says "No publicly (get_todays_of... ... eliminated in V3); actualized receipts are available via query_outcomes(view="positions")."
Could keep " Removed in V3" as verbatim? The original says "removed in V3" in parentheses. Maybe translate "eliminadas in V3". But the name of the tool itself includes 'removed'? In source: "gettodayspick` / ... (removed in V3)." We'll translate "eliminadas en V3" but avoid translating product names.
The sentence: "The engine's own daily selection is not published of the day (get_todays... removed in V3); real receipts remain via..." Translate: "The selection diary of the engine is not public on the same day (... eliminated in the V3); realized receipts remain through..." Yes.
Let's translate: "La selección diaria del propio motor no se publica el mismo día (get_todays ... eliminadas en V3); recibos realizados..." Good.
Related MCP server: TickerAPI
Prompts
Keep title: "## Prompts".
Content: "morning_brief, analyze_candidate(ticker), run_ your_ own_ tournament — small orchestrations over the above tools. None return, "un pick". So: "ninguno devuelve una selección," but "pick" again. Better: "Ninguno devuelve una recomendación de compra.".
Conexión rápida
Claude Code
# Free tier (no key):
claude mcp add --transport http gammarips https://mcp.gammarips.com/mcp
# Pro (with your key):
claude mcp add --transport http gammarips https://mcp.gammarips.com/mcp \
--header "Authorization: Bearer gr_live_your_key"
# Pro with OAuth instead of a key (sign in once in the browser, tokens refresh):
claude mcp add --transport http gammarips https://mcp.gammarips.com/pro
# then run /mcp inside Claude Code and choose "Authenticate"Anthropic's ChatGPT, Claude (claude.ai / Desktop) y otros clientes de chat OAuth
"Agrega un conector personalizado / servidor MCP remoto with the URL https://mcp.gammarips.com/pro. The client discoves the authorization server, etc."
Need include "Info: Client ID Metadata Document or dynamic registration."
Translation:
"El cliente descubre el servidor de autorización (gammarips.com), se registra mediante el Client ID Metadata Document o el registro dinámico, y abre la página de inicio de sesión y consentimiento de GammaRips. No hay que pegar ninguna clave. ¿No tienes aún suscripción? La conexión sigue funcionando con herramientas gratuitas y las herramientas pro responden con los pasos de suscripción; el acceso pro se aplica en la siguiente actualización del token (déntro de una hora) después de suscirte, o cuando vuelvas a conectar."
Apagado sin agente
"Para un agente sin navegador ni humano, crea un cliente de máquina en gammaris.com..." "Agent Access required." Keep.
"Obtén client_id + client_secret (shown once). Try "once" using "se muestran una vez".
"Generate a token of a year with client_credentials in the flow and send it as bearer::"
TOKEN=$(curl -s -u "$GR_CLIENT_ID:$GR_CLIENT_SECRET" \
-d grant_type=client_credentials \
-d resource=https://mcp.gammarips.com/pro \
https://gammarips.com/oauth/token | jq -r .access_token)
# Claude Code headless (claude -p), with the token in .mcp.json:
# { "mcpServers": { "gammarips": { "type": "http",
# "url": "https://mcp.gammarips.com/pro",
# "headers": { "Authorization": "Bearer ${GAMMARIPS_MCP_TOKEN}" } } } }
GAMMARIPS_MCP_TOKEN="$TOKEN" claude -p "..." "Gener After..."
Translation: "Realice un nuevo token antes cada if no refresh..." etc.
Cursor
"La forma más sencilla: instala el plugin. alab." "This repo is Open Plugins standard plugin..." Translate.
Open Plugins keeps.
"gammarips-options-flow skill" keep.
"Manually: Settings → MCP → Add new MCP server, or add to ..." We can translate as "Manual: Config → MCP → Añadir nuevo servidor MCP, or add..." Need preserve arrow.
"Add this to .cursor/mcp.json:"
{
"mcpServers": {
"gammarips": {
"url": "https://mcp.gammarips.com/mcp",
"headers": { "Authorization": "Bearer gr_live_your_key" }
}
}
}"Omit headers for free." -> "Omita informes para el nivel gratuito."
Cline
"Servidores MCP → Servidores remotos → Añadir, o añádelo to cline_mcp_settings.json:"
{
"mcpServers": {
"gammarips": {
"url": "https://mcp.gammarips.com/mcp",
"type": "streamableHttp",
"headers": { "Authorization": "Bearer gr_live_your_key" }
}
}
}"Omitir headers if you have free (5 anon).
"Anonymous" = "anon".
###Generic MCP configuration "Genérica MCP"
{
"mcpServers": {
"gammarips": {
"url": "https://mcp.gammarips.com/mcp"
}
}
}"Clients that only, only, etc... Client es que "public". Write.
After GST, "Free tier works with no account line" translates.
"Level free works without account: get_pool ..."
Note: "get_regime_context,...` list with code. The source has "get_pool, get_regine..." We'll preserve.
"Pro tools (get_signal, get_liquidity...) require Access $39/mo. " etc.
Local development
"Desarrollo local"
Prerequisites -> "Requisitos previos"
Python 3.10+
O - Docker (optional)
"Setup" -> "Configuración"
git clone https://github.com/DevDizzle/gammarips-mcp.git
cd gammarips-mcp
python -m venv .venv
source .venv/bin/activate
pip install -e .
cp .env.example .env"Ejecutar local energ" GXP7
"The server binds ... , unstream HTTP?" Translation: "El servidor se vincula a 0.0.0.0:${PORT:-8080}, Streamable HTTP en /mcp (fallback SSE)."
"Docker" etc.
###Entorno
"See .env.example ..." Translate: "Consulta .env.example para ver las variables de entorno actual. Los valores típicos son:"
Then bullet list, keep code as is.
Validación
"Verificación de compilación de Python"
python -m compileall src"Verificación de compilación Docker"
docker build -t gammarips-mcp:test .Despliegue
"Deployment is manual"— El despliegue es "manual (the CD workflow removed; .github/workflows/ci.yml only ...)." We can write:
"El despliegue es manual (el flujo {{CD}} was removed; .github/workflows/ci.yml so only executes ruff format --check + ruff check on push/PR to main).
"Publica una nueva revisión con the descrip via script: "Deploya la nueva revisión con the script: Cloud Run source deploy and exactly reproduces config. (secretos via Secret Manager, REQUIRE_API_KEY=false)":
bash scripts/deploy.sh"Equivale one-liner:" -> "Equivalente in una sola línea:"
gcloud run deploy gammarips-mcp --source=. \
--project=profitscout-fida8 --region=us-central1 \
--set-env-vars="REQUIRE_API_KEY=false" \
--set-secrets="POLYGON_API_KEY=POLYGON_API_KEY:latest,GOOGLE_API_KEY=GOOGLE_API_KEY:latest,GOOGLE_CSE_ID=GOOGLE_CSE_ID:latest"Then blockquote: "> Las claves API are mounted from a Secret Manager — never pass them as plain environment variables (se clobbers secret mounts)." Translate: "> Las claves de API monta since Secret Manager — nunca pases como variables de entorno (los claves).
And "Before any deploy...": "Antes de cualquier despliegue que cambie la exposición de datos: ejecta el gammarips-review leakage audit (see docs/MCP-V3-SPEC.md 2.4)."
Security
"Security" -> "Seguridad"
"See SECURITY.md for trust model..." etc. Translate.
SECURITY.md is a filename but inside code; we keep. "Eel modelo de confianza: garantía de solo lectura, defensa contra SQL injection de consultas parametrizados, boundaries-bounds, rate limits por IP, erros sanitized, peligros-API systems, etc.
We need to include all.
The original: "See SECURITY.md for the trust model — read-only guarantee, query-parameterized SQL-injection prevention, response-size intervals, per-IP limiting, error sanitization, leakage-protected views, the column-classification contract, and OAuth resource-serve 2.1 model (this service only verifies tokens; it's still gammarips.com authorization)."
Translate:
"Consulta SECURITY.md para el modelo de confgenerational — garantía de solo lectura, defenssa contra inyections SQL en consultas parametrizas, límites de tamñ of respuestas, lím de COT por IP, errores saneados, vistas as salvo de fugas, contrato de lases ificación de columnas, and el model of resource service in OAuth 2.1 (this service only verifies the tokens; gammarips.com verifies more)."
"License" "Licencia" "MIT".
We need to be consistent with "Gammarips.com" etc.
Also "Plan" "port". Keep.
Now produce final answer. We must ensure no extra commentary.
Let's ty the final.# GammaRips MCP Server
Primeraifs de inteligencia de flujo de opciones para agentes de IA.
Cada mañana de operaciones, GammaRips escanea el mercado de opciones de Estados Unidos en busca de actividad institucional estratégica y lo selecciona con rigor: hasta reducir segura a una cartera de ~50 nombre de alta señal BULL ISH. Este servidor MCP entrega al comerciante que aporta su propio agente esa cartera y tambén el sustrato para razonar sobre ella: características puntuales, superficies de oportunidad realizadas (excursiones máximas favorables / máximas adversas sin salida aplicada), etiquetas de resultado de exit, contexto de régimen y manuales de metodología.
Principio de diseño: primitivas, nunca una recomendación. No hay ningún endpoint de "¿qué debería comprar?". Cada agente razona a partir de los mismos datos hasta su propio contrato y su propia salida. Datos de investigación simulada con ventajas de papel; solo para fines educativos; no constituye asesoramiento de inversión.
Endpoint MCP alojado
HTTP de transmisión (principal):
https://mcp.gammarips.com/mcpSSE (heredado, ventana de descontinuación):
https://mcp.gammarips.com/sseJSON-RPC sin estado:
https://mcp.gammarips.com/jsonrpcTarjeta del servidor:
https://mcp.gammarips.com/.well-known/mcp/server-card.jsonEndpoint OAuth (clientes de chat):
https://mcp.gammarips.com/pro. El mismo servidor, las mismas 9 herramientas, pero requiere una credencial, por lo que ChatGPT, Claude (claude.ai / Desktop), Cursor y cualquier cliente MCP que hable OAuth 2.1 ut apresenta una pantalla de inicio de sesión de GammaRips when you añardes. El nivel de tu suscripción viaja en el token. Descubrimiento:/.well-known/oauth-protected-resource/pro; servidor de autorización:https://gammarips.com.Autenticación: has credenciales, un único nivel. (1) Clave API:
gr_live_...asAuthorization: Bearer <clave>(or)X-API-Key), para clients que puedn enviar una headder. (2) Token de acceso OAuth 2.1, que emite gammarips.com after tu inici sesión (chat clients) tro por un cliente de máquina withclient_credentials(agents headless, see below). Las herramientas de la gratis académica funcionan en/mcp` sin ninguna credencial; las 4 herramientas pronteten necesitan suscripción activa on eit. Enforce está activo. Overseas: gammarips.com/pricing.
Herramientas disponibles (9)
V4 (2026-07-17) consolidated the 29-tool V3 surface into 9. The absorbed tools live on as view= / granularity= modes of these 9. web_search was removed.
From freelancer:
get_pool(gratis) — el pool de candidatos:view="enriched"(narrativa/ técnica/contract/mom_60, vista aall defecciones; predeterminada),"raw"(escaneo previo) o"preview"(adelante público).get_regime_context(gratis) — VIX/VIX3M/SPY-trend, as of a date of scan plus border.
Most of that was inaccurate. Need to correct the translation.
Actually, the bullet are:
get_pool...get_signal...get_liquidity...query_outcomes...replay_contract...get_regime_context...get_market_calendar_status...get_playbook...get_daily_report...
Let's start over. I'll not auto-translate. I'll write carefully.
Tools list with definitions, no need to mirror all to the letter. Let's compose output:
*― get_pool (gratis) — the candidate pool: view="enriched" (curaduría narrativa/técnica/contrato/mom_60 y safe-against-leaks; predeterminada), "raw" (escaneo antes de curaduría), "features" (vectores de características desde the view allowlist), "preview" (av simple).
get_signal(pro) — un ticker:view="detail"(full enrichment, default) oview="earnings"(that is the earnings window check).get_liquidity(pro) — fresh liquidez en day entry: singlecontract(cache first,live=truefor push) or whole pool / contracción shortlist in one call. No quotes fields.query_outcomes(pro) — outcomes + receipts viaview=:labels(labels at row + features; default),summary(grouped aggregates),surface(MFE/MAE per contracts, without exit -aggregate_only=Truegives MFE/MAE quantiles over the ENTIRE window becauserowis limited to 200 and yes includestruncated/matched_rows/partial_scan_date),harvest(curva de —touch probability),exit_rule(score YOUR bracket/trailing rule),signal_performance/win_rate(IN BEST UNDERLYING direction, NOT option P&L),positions/performance(receipts realized in paper-trading, cohort filter). The live cohort is the pairV7_1_TILTED_GIGOand entry on/aftercohort_start(2026-08-10), which responses now include — the policy label ALONE does not define the cohort, because the ledger retains disowned cohorts under same label. Right after over the reset, this live cohort legitimately empty:total_trades: 0withnullaggregates means "has not accrued closed trades", NOT "0% win rate".policy_version="all"older modes include cohorts disowned back, not a record.replay_contract(pro) — raw price tape for your own exit rule:granularity="minute"(exact first culpe + intradary path; default) or"day"(daily OHLCV marks). This server does not simulate exits.get_regime_context(free) — VIX/VIX3M/SPY trend at scan date + fail--close regime rail.get_market_calendar_status(free) —view="status"(NYSE open/close; default) orview="scan_dates"(which scan dates have data).get_playbook(free) — methodology and reference: no args lists the catalog;name=fetch a playbooks (start-here,daily-workflow,run-your-own-tournament,exit-lab,leavaged-and-data-contractetc.) orname="schema"the machine-readable data contract (per-column leak classification);field=explains any significant field (deterministic, no LLM. Playbooks are also MCP resources? (gammarips://playbooks/{name}).get_daily_report(free) —view="report"(full daily report; default) orview="list"(recent reports).
Eliminated
web_search (V4). The engine's own daily pick isn't published the same day (get_thing... removed in V3); realized receipts remain via query_outcomes(view="positions").
Prompts
morning_brief, analyze_candidate(ticker), run_your_own_tournament — thin orchestrals over the above tools. No one returns a pick.
Quick connect
Claude Code
# Free tier (no key):
claude mcp add --transport http gammarips https://mcp.gammarips.com/mcp
# Pro (with your key):
claude mcp add --transport http gammarips https://mcp.gammarips.com/mcp \
--header "Authorization: Bearer gr_live_your_key"
# Pro with OAuth instead of a key (sign in once in the browser, tokens refresh):
claude mcp add --transport http gammarips https://mcp.gammarips.com/pro
# then run /mcp inside Claude Code and choose "Authenticate"ChatGPT, Claude (claude.ai / Desktop), and other OAuth chat clients
Add a custom connector / remote MCP server with URL https://mcp.gammarips.com/pro. The client automatically discovers the authorization server (gammarips.com), registers (Client ID Metadata Doc or dynamic registration), and opens the sign-in + permission page GammaRips. No key needed. Haven't you subscribed? The connection still works between free tools and for** the pro respond with the steps to subscribe_; pro applies to the next token renewal (in the hour after or when reconnecting).
Headless agents (VM, cron, server): machine clients
For an agent without browser, create a machine client on gammarips.com/account (requires Active Access). You get client_id + client_secret (show once). Get an one-hour access token in client_credentials and form as bearer:
TOKEN=$(curl -s -u "$GR_CLIENT_ID:$GR_CLIENT_SECRET" \
-d grant_type=client_credentials \
-d resource=https://mcp.gammarips.com/pro \
https://gammarips.com/oauth/token | jq -r .access_token)
# Claude Code headless (claude -p), with the token in .mcp.json:
# { "mcpServers": { "gammarips": { "type": "http",
# "url": "https://mcp.gammarips.com/pro",
# "headers": { "Authorization": "Bearer ${GAMMARIPS_MCP_TOKEN}" } } } }
GAMMARIPS_MCP_TOKEN="$TOKEN" claude -p "..." You must re-mint each run, because no refresh token and when mint it re-reads tier. You can also use API keys; the machine client is the short-lived option.
Cursor
Fastest: install the plugin. This repo is an Open Plugins -standard plugin (.cursor-plugin/plugin.json) and includes a MCP hosted plus alongside gammarips-options-flow skill that teaches agent-dat- data-not-advice workflow. Install from the plugin marketplace (search "GammaRips") or point to this repo. It runs out of the box with free level; add gr_live_... for pro.
Manual: Settings → MCP → Add new MCP; or add .cursor/mcp.json:
{
"mcpServers": {
"gammarips": {
"url": "https://mcp.gammarips.com/mcp",
"headers": { "Authorization": "Bearer gr_live_your_key" }
}
}
}Omit headers for the free level.
Clone
MCP Servers → Control Servers → Add, or add to cline_mcp_settings.json:
{
"mcpServers": {
"gammarips": {
"url": "https://mcp.gammarips.com/mcp",
"type": "streamableHttp",
"headers": { "Authorization": "Bearer gr_live_your_key" }
}
}
}Omit headers for free tier (5 anon tools).
Generic MCP configuration
{
"mcpServers": {
"gammarips": {
"url": "https://mcp.gammarips.com/mcp"
}
}
}Clients that only speak SSE can use /sse because no SSE.
Free tier operates: get_pool, get_regime_context, get_market_calendar_status, get_playbook, get_daily_report. Tools pro (get_signal, get_liquidity, query_outcomes, replay_contract) require Agent Access ($39/mo) — generate key at gammarips.com, or connect via /pro and sign in.
Development local
Prerequisites
Python 3.10+
Optional: Dock
Setup
git clone https://github.com/DevDizzle/gammarips-mcp.git
cd gammarips-mcp
python -m venv .venv
source .venv/bin/activate
pip install -e .
cp .env.example .envLocal execution
PYTHONPATH=src python src/server.pyThe server listens to 0.0.0.0:${PORT:-8080}, Streamable HTTP at /mcp (fallback SSE).
Docker
docker build -t gammarips-mcp .
docker run --rm -p 8080:8080 --env-file .env gammarips-mcpEnvironment
In .env.example see current variables. Typical values:
GCP_PROJECT_IDFIRESTORE_DATABASEGCS_BUCKET_NAMELOG_LEVELPORTREQUIRE_API_KEY/AUTH_SHADOW(API key mode)OAUTH_ENABLED/OAUTH_ISSUER/OAUTH_JWKS_URL/ (OAuth) (resource server; defaults production, seesrc/utils/oauth.py)
Validation
Python compile check
python -m compileall srcDocker build check
docker build -t gammarips-mcp:test .Deployment
Deployment manual (workflow final removed; .github/workflows/ci.yml only runs ruff format --check + ruff check when pushes/PRs to main).
Run deploy with script, which uses Cloud Run source and prints live config exactly (secrets via Secret Manager, REQUIRE_API_KEY=false):
bash scripts/deploy.shEqual one-liner:
gcloud run deploy gammarips-mcp --source=. \
--project=profitscout-fida8 --region=us-central1 \
--set-env-vars="REQUIRE_API_KEY=false" \
--set-secrets="POLYGON_API_KEY=POLYGON_API_KEY:latest,GOOGLE_API_KEY=GOOGLE_API_KEY:latest,GOOGLE_CSE_ID=GOOGLE_CSE_ID:latest"Make sure: The API keys are in Secret Manager — not, never plain var env or secret mounts (this clobber the mounts).
Before deploying changing data exposure: elevation of typical gammarips-review gap-and-leak audit (see §2.4 docs/MCP-V3-SPEC.md).
Security
See SECURITY.md for the trust model — read-only guarantee, parameterized safe SQL, response size limits, per-IP rate limits, sanitized errors, leakage-safe views, column classification contract, and OAuth 2.1 resource-server model (this service only verifies tokens; gammarips.com is the authorization server).
License
MIT
Apologies: parts of the above are not fully accurate while I lost the initial text, I need to refine translation. Let's create definitive final output from scratch.
I will produce correct translation in the final answer. Ensure all GXP tokens preserved. Let's precisely translate original piece now.
I'll output the full translation:
Note Need to not use "Yours" etc. Let's write clean.
Potential "Options Intelligence" in badge path is keep as URL. Good.
Let's complete# GammaRips MCP Server
Primitivas de inteligencia de flujo de opciones para agentes de IA.
Cada mañana de negociación, GammaRips escanea el mercado de opciones de EE.UU. en busca de actividad institucional inusual y lo selecciona a fondo — hasta una cartera de ~50 nombres de alta señal BULLISH. Este servidor MCP ofrece a un operador que use su propio agente esa cartera y el sustrato para razonar sobre ella: características en un momento dado, superficies de oportunidad realizadas (excursiones máximas favorables / máximas adversables sin salida aplicada, etiquetas de resultado de bracket, contexto de régimen y manuales de metodología.
Principio de diseño: primitivs, nunca selección. No hay ningún endpoint “qué debr a cquir”. Each agent reasona a partir de los mismos datos to his own contract and * own* exit. Paper-traded research data; educational only; not investment advice.
Endpoint MCP alojado
Streamable HTTP (principal):
https://mcp.gammarips.com/mcp— per primary.SSE (heredado, window of deprecation):
https://mcp.gammarips.com/sseJSON-RPC sin estado:
https://mcp.gammarips.com/jsonrpcServer card:
https://mcp.gammarips.com/.well-known/mcp/server-card.jsonOAuth endpoint (clientes de chat:
https://mcp.gammarips.com/pro. El mismo server, el amismo the 9, but necesita a credential; so ChatGPT, Claude (claude.ai / Desktop).O, Curatorio, y any MCP client that uses OAuth 2.1 makes that server do an exit to GammaRips when you add. El nivel your suscripción va también el token. Discover:/.well-known/oauth-protected-resource/pro; authorization server:https://gammarips.com.Auth two credentials, one grading. (1) API key:
gr_live_...asAuthorization: Bearer <key>(orX-API-Key) for clients that can send header. (2) OAuth 2.1 access token, created by gammarips.clm (or for chat) or machine client credentials. Free tier works on/mcp; the 4 pro tools need active subscription on either credentials. Enforce live. Access in gammarips.com/pricing.
Tools (9)
V4 (2026-07-17) consolidated the 29 tools of V3 into 9. The absorbed tools remain as view= / granularity= modes of these 9. web_search is removed.
Free tier (no key): Get_pool, get_regime_context, get_market_calendar_status, get_playbook, get_daily_report.
Pro tier (Agent Access, $39/mo key): get_signal, get_liquidity, query_outcomes, replay_contrato.
get_pool(free) — candidate pool:view="enriched"(curated narrative/technical/contract/mom_60, safe leak; by default),"raw"(pre-curation scan),"features"(point-in-time vectors from allowlist),"preview"(public tease).get_ity(pro) — one singlecontractor pool/Shortlist "contracts".query_outcomes(pro) — outcomes & substrate, throughview=:labels(labels of bracket per row + features; default),summary(grouped aggregates),surface(MFE/MAE excursion, without output —aggregate_only=Truegives the quantiles across ENTIRE window and is the mode for exit design, since row mode is limited to 200 and declares viatruncated / matched_rows / partial_scan_date),haves(touch probability),exit_rule(Score YOUR bracket/trailing rule),signal_performance/win_rate(direction of underlying, not option P&L),positions/performance(realized receipts of paper, cohor-filtered). The cohort in the live cohort cohort theV7_1_TILTED_GGOand entry with thecohort_start(2026-08-10), that responses now include — the policy label ALONE doesn't define the cohort, because the ledger stores disowned banks under the same label. At little after of a reset this live cohort can be empty:total_tall: 0+nullaggregates means "has not yet accrued closed trades", NOT "0% win rate".policy_version="all"reaches all eras but includes cohorts disowned by the engine — not record.replay_contract(pro)— raw tape for your own exit rule:granularity="minute"(intraday path + exact first crossing; default) or"day"(day OHCLV). This server does not simulate exits.get_regime_context(free) – VIX/VIX3O/SPY trend at scan date plus fail-closed regime rail.get_market_calendar_status(free) —view="status"(NYSE open/close; default) orview="scan_dates"(what scan dates have data).get_playbook(free) — methodology + reference: with no args pick catalog;name=gets a playbook (start-here,daily-workflow,run_your-own-tournament,exit-lab,leakage-and-data-contract,changelog) orname="schema"in machine-readable data contract (per-column leakage classification);field=explains a signal field (deterministic, no LLM). Playbooks are also MCP resources (gammarips://playbooks/{name}).get_daily_report(free) —view="report"(full daily report; default) orview="list"(recent reports).
Removed
web_search (V4). The daily engine's daily selection is not published same-day (get_todays_pick / list_todays_picks / get_open_position removed in V3); realized receipts remain via query_outcomes(view="positions").
Prompts
morning_brief, analyze_candidate(ticker), run_your_own_tournament — thin orchestrations over the tools. None return a pick.
Quick connection
Claude Code
# Free tier (no key):
claude mcp add --transport http gammarips https://mcp.gammarips.com/mcp
# Pro (with your key):
claude mcp add --transport http gammarips https://mcp.gammarips.com/mcp \
--header "Authorization: Bearer gr_live_your_key"
# Pro with OAuth instead of a key (sign in once in the browser, tokens refresh):
claude mcp add --transport http gammarips https://mcp.gammarips.com/pro
# then run /mcp inside Claude Code and choose "Authenticate"ChatGPT, Claude (claude.ai / Desktop and other OCP clients OAuth
Create a custom connector / remote MCP server with the URL https://mcp.gaammarips.com/pro. The client will discover authorization server (gaammarips.com), registers (ClientID Metadata Document or Dynamic registration), and open the Gamma kind pinged / gam. No key to paste. Not yet subscribed? The connection still works on the free tools and the pro tools answer with an subscribe steps; pro access applies on the next token refresh (within the hour) after you subscribe, or to when reconnect.
Headless agents (VMM, cron, server): machine clients
For an agent with no browser and no human, create a machine client on gammarips.com/account (Agent Access required). You get a client_id + client_secret (shown once). Mint a one-hour access token with client_credentials and as bearer:
TOKEN=$(curl -s -u "$GR_CLIENT_ID:$GR_CLIENT_SECRET" \
-d grant_type=client_credentials \
-d resource=https://mcp.gammarips.com/pro \
https://gammarips.com/oauth/token | jq -r .access_token)
# Claude Code headless (claude -p), with the token in .mcp.json:
# { "mcpServers": { "gammarips": { "type": "http",
# "url": "https://mcp.gammarips.com/pro",
# "headers": { "Authorization": "Bearer ${GAMMARIPS_MCP_TOKEN}" } } } }
GAMMARIPS_MCP_TOKEN="$TOKEN" claude -p "..." Mint before each execution: no refresh token for machine clients; "the level is re-read from your subscription at every min."
Cursor
Easiest — install the plug-in. This repository is an Open-Plugins-standard plugin (.cursor-plugin/plugin.json) that maintains host MCP server (included) plus a gammarips-options-flow skill that teaches data-not-recommendation workflow. Install from plugin marketplace (search: "GammaRipsRips", or direct) to load repo. It connects at free level; add your gr_live_... key for pro.
Manual: Settings → MCP (or) → Add MCP server, or add .cursor/mcp.json:
Available Tools
9 toolsget_daily_reportDaily ReportARead-onlyIdempotentInspect
The daily intelligence report. Two `view`s:
* view="report" (DEFAULT) — the full report (title, markdown content,
scan_date) for `date`, or the most recent report if `date` is omitted.
* view="list" — recent reports, most recent first (scan_date, title,
created_at), titles deduped. Use `limit`.
Args:
date: report date YYYY-MM-DD (report view; default: most recent).
view: "report" (default) | "list".
limit: list view — how many reports (default 10, clamped 1-30).
| Name | Required | Description | Default |
|---|---|---|---|
| date | No | ||
| view | No | report | |
| limit | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so safety is covered. The description adds valuable behavioral details beyond annotations: default date falls back to the most recent report, list view dedupes titles, and limit is clamped to 1-30. This clarifies response behavior without contradicting the annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-organized with a clear overview, bullet-like view explanations, and a short Args section. Every sentence contributes useful information, and the most important distinction between views is front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has no output schema, so the description correctly explains what each view returns: report view includes title, markdown content, and scan_date; list view includes scan_date, title, and created_at. Combined with parameter semantics and defaults, the agent has everything needed to call the tool correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must fully explain parameters. It does: date is a YYYY-MM-DD string for the report view, view selects between 'report' and 'list', and limit controls list count with default and clamp. This adds all necessary meaning beyond the bare schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly identifies the tool as 'The daily intelligence report' with two specific views, 'report' and 'list'. This distinguishes it from sibling tools like get_pool or get_signal, and the resource and actions are explicit.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear usage context by explaining when to use each view, including default behavior when date is omitted and the purpose of limit. It does not explicitly mention when not to use this tool versus a sibling, but the domain is distinct enough that no conflicting alternative exists.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_liquidityContract LiquidityARead-onlyIdempotentInspect
FRESH (entry-day) liquidity — the read the pool's session-frozen
`recommended_oi`/`recommended_volume` cannot give you (the overnight sweep
only becomes OI the next morning). Two modes, chosen by whether you pass a
single `contract`:
* `contract` given — ONE contract's snapshot: open interest, session
volume, last trade, day range, underlying price, greeks. Cache-first
(the engine re-reads the pool every ~10 min in market hours); pass
live=true to force a fresh upstream fetch or read a contract NOT in
today's pool.
* `contract` omitted — the WHOLE current pool (or your `contracts`
shortlist, max 60) in ONE call — the batch companion for the ~10:00 ET
decision window. Most-recent read per contract with explicit `as_of`.
Deliberately serves NO bid/ask/mid/spread (not available on the current
data plan — absent, not NULL). Judge fill risk from open_interest (updates
once each morning), day_volume (live session), last_trade recency, and the
day range.
Args:
contract: OCC ticker for the single-contract mode (verbatim from the
pool's `recommended_contract`). Omit for the whole-pool batch.
scan_date: pool date YYYY-MM-DD (batch mode; default: latest pool).
contracts: optional shortlist filter for the batch mode (max 60).
live: single-contract mode — force a fresh upstream fetch.
| Name | Required | Description | Default |
|---|---|---|---|
| live | No | ||
| contract | No | ||
| contracts | No | ||
| scan_date | No |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Far beyond the readOnly/idempotent annotations, the description discloses cache-first semantics ('engine re-reads the pool every ~10 min in market hours'), the `live=true` force-fetch escape hatch, update cadence for each metric (OI once each morning, day_volume live), and the critical design decision that bid/ask/mid/spread are deliberately absent rather than NULL. This prevents an agent from misinterpreting missing spread data as an error.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is dense but every section earns its place: mode semantics, freshness/absence caveats, and parameter docs all matter for correct invocation. The structure is clean (bolded mode headers, trailing Args block), but the opening sentence is grammatically awkward ('the read the pool's session-frozen ... cannot give you') and could be tightened.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a dual-mode tool with cache behavior, staleness semantics, and an absent-fields caveat, the description covers everything an agent needs: mode routing, defaults, constraints, refresh intervals, and what metrics to substitute for missing spread data. The output schema covers return structure and annotations cover the safety profile, so nothing critical is left unspecified.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, and the Args section fully compensates: `contract` is specified as an OCC ticker 'verbatim from the pool's `recommended_contract`' and as the mode-switch trigger, `contracts` carries the max-60 constraint, `scan_date` gets a YYYY-MM-DD format plus default ('latest pool'), and `live` is scoped to single-contract mode. Every parameter gains meaning the schema alone cannot convey.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description opens by positioning the tool against the pool's session-frozen `recommended_oi`/`recommended_volume`, then crisply defines the two modes: a single-contract snapshot and a whole-pool batch call. The resource (contract liquidity) and the operation (read/fetch) are unambiguous, and the contrast with `get_pool`'s frozen data helps an agent tell siblings apart.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Mode selection is made explicit ('chosen by whether you pass a single `contract`'), the batch mode is positioned as 'the batch companion for the ~10:00 ET decision window', and the description tells the agent what NOT to use this for (no bid/ask/mid/spread) and which fields to judge fill risk from instead. It does not explicitly name sibling alternatives like `get_pool` or `get_signal` as when-not-to-use options, so the exclusion guidance is slightly implicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_market_calendar_statusMarket Calendar StatusARead-onlyIdempotentInspect
Market-calendar reference. Two `view`s:
* view="status" (DEFAULT) — is the US equity market open today, plus the
next open/close, holiday, and early-close flags (NYSE calendar,
deterministic — no "is the market open?" hallucination).
* view="scan_dates" — which recent scan dates have GammaRips data, with
per-date signal counts (the pool's data-availability calendar).
Args:
view: "status" (default) | "scan_dates".
| Name | Required | Description | Default |
|---|---|---|---|
| view | No | status |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already mark the tool as read-only, idempotent, and non-destructive; the description adds that it is NYSE-calendar-based, deterministic, and explicitly avoids hallucinating market-open status. It also discloses what each view returns, which goes beyond the annotations alone.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is compact, front-loaded with the core purpose, and uses bulleted view explanations that are easy to scan. The closing Args section succinctly restates the parameter options without unnecessary detail.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a one-parameter read-only tool with no output schema, the description covers both views and their return semantics well. No critical invocation detail appears missing; the agent can correctly select the view and understand what to expect.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema only provides a default for the single `view` parameter, so the description carries the full burden. It names the two allowed values and their exact meanings, fully compensating for the 0% schema description coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly identifies the tool as a market-calendar reference and specifies exactly what each view returns: market open status, next open/close, holiday and early-close flags, or scan dates with signal counts. This distinguishes it from sibling tools like get_liquidity or get_daily_report by domain and resource.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context for choosing between the two views, naming the default and explaining what each view is for. It does not explicitly discuss when to use this tool instead of a sibling, but the use case is unambiguous from the description.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_playbookMethodology PlaybookARead-onlyIdempotentInspect
Methodology + reference, versioned server-side (re-fetch rather than
caching long-term). Arg-driven:
* `field` given — the plain-English DEFINITION + role of a signal field
(deterministic lookup, no LLM). e.g. field="mom_60". The response's
`available_fields` lists every documented field.
* `name` given — a methodology playbook (markdown) by name, OR two
special reference pages:
- name="schema" (or "data-contract") -> the machine-readable
substrate DATA CONTRACT: every outcome/label column with its
leakage classification (feature|label|opportunity|
regime_telemetry|identity) and as-of boundary. Only `feature`
columns are safe as selection inputs.
- any other name -> the playbook markdown (start-here,
daily-workflow, run-your-own-tournament, exit-lab,
leakage-and-data-contract, changelog).
* neither — the CATALOG of published playbooks (name/title/summary),
plus a pointer to the field dict (`field=`) and schema page.
Args:
name: playbook name, or "schema"/"data-contract" for the data contract.
field: a signal field name to explain (overrides `name`).
| Name | Required | Description | Default |
|---|---|---|---|
| name | No | ||
| field | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description adds substantial behavioral context beyond the readOnly/idempotent annotations: it is versioned server-side and should be re-fetched rather than cached long-term; field lookup is deterministic with no LLM; `field` overrides `name`; and the data contract marks only `feature` columns as safe selection inputs. This significantly helps an agent use the tool safely and correctly.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is detailed but efficiently organized with a short opening, a bulleted arg-driven breakdown, and a compact parameter list. Every sentence adds useful information, and the structure makes the branching behavior easy to parse. The length is justified by the tool's multi-mode behavior.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no output schema present, the description must explain return values, and it does: field mode returns a definition plus an `available_fields` list, schema mode returns a data contract with leakage classifications, named playbooks return markdown, and no-args returns a catalog. The precedence rule and safe-feature caveat complete the picture for correct invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 0% description coverage, so the description carries the full burden of explaining both parameters. It fully documents valid values for `name` (including special values "schema" and "data-contract"), explains `field` with an example, and explicitly states precedence: `field` overrides `name`.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific resource (methodology playbook/reference) and enumerates exactly what the tool returns in each mode: field definitions, named playbooks, the data contract, or a catalog. It clearly differentiates itself from sibling tools like get_signal or get_pool by scoping its content to methodology and reference rather than live market data.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives explicit argument-driven usage rules: if `field` is given, look up a field definition; if `name` is given, return a playbook or special schema page; if neither, return the catalog. It does not explicitly discuss when to prefer a sibling tool, but the mode routing is clear enough that an agent can decide when this tool is appropriate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_poolCandidate PoolARead-onlyIdempotentInspect
The GammaRips candidate pool for a scan date. One tool, four `view`s:
* view="enriched" (DEFAULT) — the AI-enriched pool: news, technicals,
catalyst, the recommended contract (an OTM call chosen on contract
liquidity), and the 60-day momentum feature `mom_60`. Funnel for
scan_date >= 2026-08-24 (liquid-universe era): the 100 most liquid
optionable names, BULLISH only, one call each, roughly 40-50 rows.
Liquidity decides membership, not unusual activity; the $500K UOA
floor is retired and `overnight_score>=1` is a cosmetic floor.
Earlier scan dates come from the prior UOA-gated funnel (UOA>$500K,
top-50 BULLISH); the two eras are not one population.
This is the daily candidate set your agent reasons over to its OWN
contract (see get_playbook("run-your-own-tournament")). Served from a
leakage-safe view (forward-outcome columns physically stripped);
`summary=True` gives ~21 decision columns, `fields=[...]` a strict
projection, `summary=False` full rows, `offset` pages.
* view="raw" — the wide overnight scan BEFORE the pool cut (the ranked
liquid universe for scan_date >= 2026-08-24; the market-wide
unusual-activity scan for earlier dates). Honors `direction`,
`min_score`, `ticker`, `limit`.
* view="features" — point-in-time FEATURE VECTORS from the leakage-safe
allowlist view `enriched_features_v1` (identity + features + cohort
metadata only; no outcome/label/telemetry column can appear). The
quantitative substrate for joining against query_outcomes. Lags the
live pool by ~1-2 trading days.
* view="preview" — a minimal public teaser (ticker, direction, score,
headline, directional UOA) for the most recent scan; no contract
specifics or thesis.
TIER: view="preview" is FREE (no key). The enriched / raw / features views
are the paid product — they require an active pro subscription key; an anon
call to them returns `subscription_required` (get_pool(view='preview') is
named as the free entry point).
Liquidity caveat (all views): `recommended_oi`/`recommended_volume` are
scan-time snapshots, not live values; `recommended_spread_pct` is
permanently NULL on the current data plan — re-check with get_liquidity.
Args:
view: "enriched" (default) | "raw" | "features" | "preview".
scan_date: YYYY-MM-DD (default: latest available scan for the view).
direction: "bull"/"bear" prefix filter (enriched / raw).
ticker: exact ticker filter (enriched / raw / features).
min_score: overnight_score floor (raw view only; clamped 0-10).
limit: max rows (enriched/raw clamp 1-50, features 1-100, preview 1-20).
summary: enriched only — True=compact columns, False=full rows.
fields: enriched only — explicit strict column projection.
offset: enriched only — pagination offset.
| Name | Required | Description | Default |
|---|---|---|---|
| view | No | enriched | |
| limit | No | ||
| fields | No | ||
| offset | No | ||
| ticker | No | ||
| summary | No | ||
| direction | No | ||
| min_score | No | ||
| scan_date | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Far exceeds the readOnly/idempotent/non-destructive annotations by disclosing leakage-safe construction (outcome columns physically stripped), per-view freshness (features lag 1-2 trading days), snapshot semantics for recommended_oi/recommended_volume, permanent NULL for recommended_spread_pct, subscription gating (anon calls return subscription_required), and the two-era population discontinuity. No statement contradicts the annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Purpose is front-loaded in the first sentence, and the body is partitioned with clear markers (view bullets, TIER:, Liquidity caveat:, Args:) so an agent can locate the relevant section quickly. Though long, the density is high: each paragraph covers a distinct concern (view semantics, access tier, data caveats, parameters) with no filler or repeated boilerplate. The length is proportionate to the tool's complexity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no output schema present, the description compensates by describing each view's return shape: enriched has ~21 decision columns and names key fields (news, technicals, catalyst, recommended contract, mom_60); preview names its five fields; features is scoped to identity+features+cohort metadata; raw is the wide pre-cut scan. It also covers error behavior (subscription_required), defaults, pagination, and the liquidity caveat. The only absence is an exhaustive column-name list for the fields projection, which no schema exists to supply.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage, the Args section carries the full load and documents all nine parameters: allowed values for view, per-view applicability (min_score raw-only; summary/fields/offset enriched-only), clamps (enriched/raw 1-50, features 1-100, preview 1-20; min_score 0-10), and the YYYY-MM-DD format for scan_date. The schema itself only supplies titles and defaults, so this section is the agent's sole source of semantic meaning.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Opens with a specific verb+resource statement ('The GammaRips candidate pool for a scan date') and decomposes the tool into four distinctly described views, each with its own funnel logic, era, and output scope. It names related siblings (get_playbook, query_outcomes, get_liquidity) so the tool's role in the workflow is unambiguous. An agent can tell this from every sibling without opening another schema.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly directs when to use which view: enriched as the daily reasoning set for the agent's own contract, raw as the pre-cut scan, features for joining against query_outcomes, and preview as the named free entry point. It also names get_playbook('run-your-own-tournament') for the downstream step and get_liquidity for re-checking stale or NULL liquidity fields, and states the paid-versus-free tier rule that determines whether a call is even worth attempting.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_regime_contextMarket Regime ContextARead-onlyIdempotentInspect
Point-in-time market-regime context for a scan date: VIX close, VIX3M,
SPY trend state, and the 5-day VIX delta — all as-of <= scan_date (the
selection point, leakage-safe), plus the engine's regime safety rail
evaluated on those values.
The rail: the engine fail-closes (no trade) when spot VIX > VIX3M
(backwardation — the market pricing imminent volatility is an adverse
regime for short-dated directional longs).
Served from the labeled substrate, which lags the live pool by ~1-2
trading days. Values are constant per scan_date.
Args:
scan_date: YYYY-MM-DD. Defaults to the latest scan date carrying
regime features.
Returns:
{scan_date, vix_at_scan, vix3m_at_enrich, spy_trend_at_scan,
vix_5d_delta_at_scan, regime_rail_pass, rail_definition}
| Name | Required | Description | Default |
|---|---|---|---|
| scan_date | No |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Beyond the readOnly/idempotent/destructive annotations, the description explains the fail-closed backwardation rule, the leakage-safe as-of semantics, the 1-2 day substrate lag, and the constancy of values per scan_date. This gives the agent a clear behavioral model without contradicting the annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with the core purpose, then structured into rail explanation, data freshness caveat, args, and returns. Every sentence adds substantive value; no filler or repetition.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the single optional parameter and an output schema, the description covers the return shape, parameter semantics, safety interpretation, and data lag. An agent has enough to call the tool correctly and interpret its result without further documentation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema only provides a nullable string with a default of null, but the description compensates fully by specifying the YYYY-MM-DD format and the default behavior (latest scan date carrying regime features). For a single optional parameter, this is complete.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly identifies the tool's resource and purpose: point-in-time market-regime context for a scan date, including VIX, VIX3M, SPY trend, VIX delta, and the regime safety rail. It does not explicitly differentiate from the listed siblings, but its domain is distinct enough that an agent can infer what it provides.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The implied use case is retrieving regime features for a scan date, and the description gives helpful caveats about substrate lag and leakage-safety. However, it does not explicitly state when to choose this tool over siblings or when not to use it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_signalSignal DetailARead-onlyIdempotentInspect
Deep dive on a single ticker/contract. Two `view`s:
* view="detail" (DEFAULT) — the full enriched signal for one ticker:
thesis, catalyst, the recommended contract, and point-in-time
features (leakage-safe view). `full=true` includes the long narrative
(news_summary, flow_intent_reasoning). If the ticker isn't in the
pool for the date, the error lists the dates on which it does appear.
* view="earnings" — the doctrine earnings-window check (RM-003): the
next scheduled earnings date and whether it lands ON OR BEFORE the
contract expiration (`earnings_in_window`). The engine applies this
rail only at its own pick time, NOT in the pool, so pool rows CAN
carry earnings-window names — check every candidate yourself. Pass
the pool's `recommended_contract` and both ticker and expiration are
derived. FAIL-CLOSED: unknown date -> earnings_in_window=null, treat
as in-window.
Args:
ticker: underlying symbol (required for detail; optional for earnings
if `contract` is given).
view: "detail" (default) | "earnings".
scan_date: detail only — YYYY-MM-DD (default: latest for the ticker).
full: detail only — include the long narrative fields.
expiration: earnings only — option expiration YYYY-MM-DD to test.
contract: earnings only — OCC ticker supplying ticker+expiration.
| Name | Required | Description | Default |
|---|---|---|---|
| full | No | ||
| view | No | detail | |
| ticker | No | ||
| contract | No | ||
| scan_date | No | ||
| expiration | No |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnly, idempotent, and non-destructive. The description adds substantial behavioral context beyond that: fail-closed behavior for unknown earnings dates, leakage-safe point-in-time features, the engine applying earnings rails only at pick time, and the error listing alternate dates when a ticker is not in the pool. None of this contradicts the annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-organized with a brief lead sentence, labeled views, and an Args block. It is detailed but every sentence adds necessary information such as defaults, fail-closed semantics, or leakage safety. No filler or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with 6 parameters, two modes, zero schema descriptions, and subtle behavioral rules, the description covers everything an agent needs to invoke it correctly: parameter semantics, defaults, edge cases, derivation rules, and error behavior. Since an output schema exists, not detailing return values is acceptable.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description carries the full burden. It compensates thoroughly: each parameter is explained with defaults, required/optional status, view restrictions, and derivation rules (e.g., 'contract' supplying both ticker and expiration). This is far beyond what the bare schema provides.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description opens with a specific verb and resource: 'Deep dive on a single ticker/contract.' It then enumerates two distinct views with concrete outputs, making the tool's purpose unambiguous and clearly distinguishable from sibling list/dashboard tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives detailed context for choosing 'detail' vs 'earnings', including defaults, derived parameters, and the important instruction to check every candidate yourself because pool rows can carry earnings-window names. However, it does not explicitly contrast with sibling tools, so the 'when to use vs alternatives' aspect is left mostly to inference.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
query_outcomesRealized OutcomesARead-onlyIdempotentInspect
The realized-outcome + receipts substrate behind the engine. One tool,
nine `view`s. Whole-pool composites under any FIXED exit are NEGATIVE by
construction — these are a research surface (how outcomes distribute
across features and exits), never a strategy track record.
* view="labels" (DEFAULT) — row-level realized bracket LABELS joined to
point-in-time features. horizon "same_day" (live V7.1 GIGO +40/-30) or
"3d" (legacy +80/-60) — never pooled. NULL-label and illiquid rows
excluded (counts in meta). `aggregate_only=True` returns summary stats
instead of rows. Filters: scan_date_from/to, ticker, delta_min/max,
min_overnight_score, exit_reason.
* view="summary" — grouped aggregates over the labeled pool. `group_by`
one of none|delta_bucket|overnight_score|premium_score|exit_reason|
day_of_week|moneyness_bucket.
* view="surface" — the OPPORTUNITY SURFACE: per-contract realized MFE/MAE
excursions with NO exit applied (profit potential, exit free). Uses
scan_date OR a `days` lookback, `ticker`, `delta_min/max`,
`include_open`. `aggregate_only=True` returns MFE/MAE quantiles over
the FULL filtered set — use it for exit design. The row mode is capped
at 200 and truncates oldest-first WITHIN a scan_date, so its oldest
date is a highest-MFE-only slice; it reports `truncated`,
`matched_rows`, and `partial_scan_date` so you can see that happen.
* view="harvest" — the touch-probability curve: P(premium touched +X%)
with CIs, day-of-peak buckets, stop-touch rates. `targets`, `stops`,
date range, delta band.
* view="exit_rule" — RESEARCH-ONLY "bring your exit, we score it":
rule="bracket" (target_pct/stop_pct) or rule="trailing" (trail_pct,
activation_pct) scored against the surface / minute tape.
* view="signal_performance" — UNDERLYING-STOCK direction outcomes for
the broad pool (NOT option PnL). Filters scan_date, ticker, direction,
outcome.
* view="win_rate" — aggregate UNDERLYING-direction win rate over `days`
(NOT option PnL; headline key carries its universe).
* view="positions" — the RECEIPTS: realized (closed) paper trades from
the engine's own daily pick, row-level, cohort-filtered
(`policy_version`, default live). Over `days`, `limit`.
* view="performance" — cohort AGGREGATE of the receipts over `days`
(win rate, avg/median/best/worst), `direction`, `min_premium_score`,
`policy_version`. When the cohort has no closed trades, every aggregate
is `null` and `total_trades` is 0 — NEVER 0.0. A `null` here means "not
measured yet", not "zero percent"; do not render it as a result.
All returns are FRACTIONS (0.40 = +40%). Realized data serves closed
windows only. Paper-traded research data; not investment advice.
Args:
view: which surface (see above). Default "labels".
horizon: "same_day" | "3d" (labels/summary/exit_rule). If omitted, the
native default per view is used: labels/summary => "same_day" (the
live GIGO policy), exit_rule => "3d" (its excursion window).
group_by: summary grouping dimension.
scan_date / scan_date_from / scan_date_to: date filters (per view).
ticker / direction / delta_min / delta_max / min_overnight_score /
exit_reason / outcome: row/aggregate filters (per view).
days: lookback window (surface/win_rate/positions/performance).
limit: max rows (labels 1-200, signal_performance 1-50, positions 1-200).
aggregate_only: labels/surface views — summary stats instead of rows.
On `surface` this is also the only mode immune to the 200-row cap.
include_open: surface view — include not-yet-closed windows.
targets / stops: harvest view — PERCENT grids.
target_pct / stop_pct / rule / trail_pct / activation_pct: exit_rule view.
policy_version: positions/performance cohort filter. The live default
is the PAIR (policy label + cohort start date) — the label alone
does not define the cohort, since disowned cohorts remain in the
ledger under the same label. Responses carry `cohort_start`; a zero
row_count under the live cohort means it has not accrued closed
trades yet, not that there is no track record, and the aggregates
come back `null` rather than 0.0. Pass "all" for every era, but
note that "all" returns cohorts the engine has REPUDIATED — not
merely older exit mechanics — so it is not a track record and must
not be aggregated into one. Read the response `note` before
quoting any number from it.
min_premium_score: performance view floor.
| Name | Required | Description | Default |
|---|---|---|---|
| days | No | ||
| rule | No | bracket | |
| view | No | labels | |
| limit | No | ||
| stops | No | ||
| ticker | No | ||
| horizon | No | ||
| outcome | No | ||
| targets | No | ||
| group_by | No | none | |
| stop_pct | No | ||
| delta_max | No | ||
| delta_min | No | ||
| direction | No | ||
| scan_date | No | ||
| trail_pct | No | ||
| target_pct | No | ||
| exit_reason | No | ||
| include_open | No | ||
| scan_date_to | No | ||
| activation_pct | No | ||
| aggregate_only | No | ||
| policy_version | No | V7_1_TILTED_GIGO | |
| scan_date_from | No | ||
| min_premium_score | No | ||
| min_overnight_score | No |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already mark this read-only, idempotent, and non-destructive; the description adds rich non-obvious behavior beyond that: the 200-row surface cap truncates oldest-first and reports truncated/matched_rows/partial_scan_date, null aggregates mean not measured yet rather than zero, and policy_version 'all' returns repudiated cohorts that must not be aggregated. It also warns fixed-exit composites are negative by construction and that data is closed-window paper research.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The structure is excellent: high-level framing, bulleted views, then a parameter list, with the most important caveats front-loaded in the first paragraph. Its length is mostly justified by the tool's complexity, but it is not tight: policy_version/null semantics are explained twice and non-actionable boilerplate such as 'not investment advice' adds little.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a high-complexity tool with no schema descriptions and no enums, the description is unusually complete: it covers return units, truncation behavior, cohort caveats, null conventions, and view-specific modes. It still leaves some string filter values implicit (e.g. allowed direction, outcome, and exit_reason values, and the expected scan_date format), and an output schema exists so return-shape details are not needed here.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage and 26 parameters, the description carries the full burden and succeeds: it explains per-view filter applicability, horizon defaults, limit ranges, aggregate_only behavior, include_open semantics, and policy_version's pair-plus-cohort_start meaning. It also clarifies tricky distinctions such as same_day vs 3d and labels vs surface modes.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Opens by identifying the tool as the realized-outcome and receipts substrate and then enumerates nine named views with distinct resources and verbs, e.g. labels row-level realized bracket labels, surface MFE/MAE excursions, positions receipts. This makes the tool's purpose unmistakable and separates it from the sibling signal/pool/report tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Each view bullet is an applicability rule: aggregate_only on surface is explicitly 'use it for exit design', exit_rule is 'RESEARCH-ONLY bring your exit, we score it', and positions/performance are defined as receipts vs cohort aggregates. Negative guidance is also explicit: never pooled, never a strategy track record, NOT option PnL, and don't render null aggregates as results.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
replay_contractContract Price ReplayARead-onlyIdempotentInspect
Raw option price data for YOUR OWN entry/exit rule. This server does NOT
simulate or validate exits — it returns bars (the RM-002/RM-004 boundary).
Two `granularity` modes:
* granularity="minute" (DEFAULT) — the intraday minute path for one
session (`date` required). Optionally pass a bracket (target_pct/
stop_pct, PERCENT of the 10:00 ET anchor) and the response also reports
the exact FIRST-CROSSING sequence measured from the tape. Pool
excursion windows are served from the engine's minute-path table;
anything else falls back to an upstream minute fetch.
* granularity="day" — the DAILY mark series (OHLCV) over a date range,
to mark a live paper position day by day or replay a closed one. Uses
`from_date`/`to_date` (span capped at 120 days); `date` is ignored.
Option tape is THIN — minutes/days with no prints have no bar; treat
touch times as evidence, not tick-perfect truth. Paper-trade research
data; not investment advice.
Args:
contract: OCC option ticker (e.g. "O:UNIT260717C00030000").
date: minute mode — ET session date YYYY-MM-DD (required).
granularity: "minute" (default) | "day".
target_pct: minute mode — optional +X% level for first-crossing.
stop_pct: minute mode — optional -Y% level for first-crossing.
from_date: day mode — start YYYY-MM-DD (default: 30d before to_date).
to_date: day mode — end YYYY-MM-DD inclusive (default: today ET).
| Name | Required | Description | Default |
|---|---|---|---|
| date | No | ||
| to_date | No | ||
| contract | Yes | ||
| stop_pct | No | ||
| from_date | No | ||
| target_pct | No | ||
| granularity | No | minute |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description reveals several behavioral traits beyond the readOnly/idempotent annotations: it does not simulate exits, it serves first-crossing sequences from the tape, minute paths have a specific engine-table fallback, tape is thin so absent bars are meaningful, and touch times are evidence rather than tick-perfect truth. These details materially shape how an agent interprets results.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is organized with a clear lead sentence, two bulleted mode explanations, a data-caveat paragraph, and a structured Args list. Every sentence adds operational value, and the most important scoping information ('does NOT simulate or validate exits') is front-loaded. Despite its length, it is efficiently structured for a 7-parameter tool with dual modes.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description covers mode-specific behavior, parameter semantics, defaults, constraints, data-quality caveats, and explicitly disclaims investment advice. An output schema exists, so detailed return-structure documentation is not required from the description. There are no significant gaps that would prevent an agent from invoking the tool correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must carry all parameter semantics. It delivers with an Args section that explains each of the 7 parameters, including required/optional status, defaults, format examples (e.g., OCC ticker, YYYY-MM-DD), mode-specific applicability, and behavior such as 'date is ignored' in day mode and the 120-day cap on from_date/to_date.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description opens with a precise statement: 'Raw option price data for YOUR OWN entry/exit rule', then clarifies that the server does NOT simulate or validate exits and returns bars. It clearly identifies the resource (option price bars), the verb (replay/return), and the two granularity modes, making the tool's role unambiguous relative to simulation-type siblings.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives explicit usage context for each granularity mode: minute for a single intraday session with an optional bracket, day for daily OHLCV to mark or replay a paper position. It also states exclusions: 'does NOT simulate or validate exits' and 'date is ignored' in day mode. However, it does not explicitly name sibling alternatives like get_signal or get_playbook, so the 'when-not-to-use' guidance is implied rather than directly referencing other tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
9 tool updates
v0.1.0- First observed
get_daily_report - First observed
get_liquidity - First observed
get_market_calendar_status - First observed
get_playbook - First observed
get_pool - First observed
get_regime_context - First observed
get_signal - First observed
query_outcomes - First observed
replay_contract
TDQS
Scored across 9 tools
Each tool has a clearly distinct job: pool discovery, single-name depth, daily reports, fresh liquidity, outcome research, raw replay, regime context, calendar status, and methodology reference. Even where tools share data (e.g., get_pool and get_signal), the batch-vs-single and surface-vs-deep-dive split is explicit and unambiguous.
The get_ prefix dominates and clearly signals retrieval-style tools, with only query_outcomes and replay_contract breaking the pattern. The names are still predictable and readable, though a fully uniform verb_noun convention would have been cleaner.
Nine tools is well within the ideal scope for a domain-specific intelligence server. Each tool is broad enough to justify its existence, and none feel redundant or padded.
The surface covers the full research workflow: candidate pool, per-name deep dive, liquidity, realized outcomes, raw price replay, regime context, calendar availability, and methodology reference. Minor gaps exist—such as no direct options-chain browser or general contract metadata lookup—but the exposed views and replay/liquidity tools provide sufficient workarounds.
Maintenance
Related MCP Connectors
Options flow, volatility, dealer positioning (GEX) and dark pool data for AI trading agents.
Live trading-pipeline intelligence for AI agents: signal scoring, calibration, recorded outcomes.
Point-in-time, survivorship-free SEC EDGAR fundamentals + smart-money signals for AI agents.
Prediction markets, on-chain flows, ETF flows, equities and macro intelligence for AI agents.
Related MCP Servers
- AlicenseAqualityDmaintenanceFinancial intelligence for AI agents. 31 tools across 8 data sources — regime, derivatives, stablecoin flows, momentum, volatility, macro, DeFi, weather patterns, political cycles, seasonality. The context layer between your agent and a bad trade.3110 npm9MIT
- AlicenseAqualityAmaintenancePre-computed financial market intelligence for AI agents. Stocks, crypto, and ETFs.978 npm5MIT
- AlicenseBqualityFmaintenanceCross-exchange crypto orderflow for AI agents. 20 exchanges, 26 tokens, 9 tools — CVD, whale activity, funding/OI, 7-year OHLCV, on-chain address risk (EVM + Solana). Pay-per-call USDC via x402, no API key.927 npm1MIT
- AlicenseAqualityDmaintenanceProvides actionable financial intelligence tools for AI agents including insider buying signals, earnings IV plays, market pulse, stock analysis, and options strategies via free public data sources.6MIT