# io.github.Jorgeperez0825/v12-dfs (remote · v12dfs-production.up.railway.app)

AI-driven DFS lineup optimizer for MLB & NBA — build FanDuel & DraftKings lineups via MCP.

- Trust score: 58/100 (low)
- Change this week: +6
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-08-03

## Components

- remote · `v12dfs-production.up.railway.app`: 58/100 (this document), [markdown](https://verifymcp.io/servers/jorgeperez0825-v12-dfs/v12dfs-production.md), [page](https://verifymcp.io/servers/jorgeperez0825-v12-dfs/v12dfs-production)

## Channel facts

- Endpoint: `https://v12dfs-production.up.railway.app/mcp`
- Transports: `streamable-http`
- Auth: `required`
- Version: `1.0.0`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically against the live server, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-08-03.

- **Endpoint Security**: 57/100
  - The endpoint's TLS certificate is valid, in date, and uses a strong key.
  - Authorisation not fully verified: no authorisation is required to call this server, and 32 tool(s) never declared a destructiveHint. The MCP spec treats an absent hint as destructive by default, so we cannot call this surface safe.
  - HTTPS is enforced; there's no plaintext access path.
  - HSTS check failed: the Strict-Transport-Security header is absent.
  - DNSSEC check failed: this domain isn't protected by DNSSEC.
- **Transport & Reachability**: 100/100
  - Verified streamable-http transport via a live MCP handshake.
- **Schema Quality & AI Usability**: 43/100
  - AI-judged instruction clarity (fair).
  - Context-footprint check failed: tool/resource definitions use about 6878 tokens (~214/item across 32 items; 32 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 27/100
  - Stability observed for 8 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 77/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 31% of tool parameters carry a description.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.

## Install

### Claude

```bash
claude mcp add --transport http jorgeperez0825-v12-dfs https://v12dfs-production.up.railway.app/mcp
```

### Codex

```toml
[mcp_servers.jorgeperez0825-v12-dfs]
url = "https://v12dfs-production.up.railway.app/mcp"
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "jorgeperez0825-v12-dfs": {
      "type": "remote",
      "url": "https://v12dfs-production.up.railway.app/mcp",
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add jorgeperez0825-v12-dfs --url https://v12dfs-production.up.railway.app/mcp --transport streamable-http
```

### Hermes

```yaml
mcp_servers:
  jorgeperez0825-v12-dfs:
    url: "https://v12dfs-production.up.railway.app/mcp"
```

### Other

```json
{
  "mcpServers": {
    "jorgeperez0825-v12-dfs": {
      "type": "http",
      "url": "https://v12dfs-production.up.railway.app/mcp"
    }
  }
}
```

The mcpServers block is a cross-client convention. Remote transports vary, so check your client's docs.

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-08-02 (score 58, +1)

No change was recorded against any check on this day. Stability & Change Management went from 20 to 23. That category is still filling its 30-day observation window: 6 days of observed history at the previous scan, 7 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-07-31 (score 57, +3)

- [functional] We updated how we score, so this day's move reflects our rubric, not a change to the server

### 2026-07-30 (score 54, 0)

- [functional] We updated how we score, so this day's move reflects our rubric, not a change to the server

### 2026-07-29 (score 54, +1)

No change was recorded against any check on this day. Stability & Change Management went from 7 to 10. That category is still filling its 30-day observation window: 2 days of observed history at the previous scan, 3 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-07-28 (score 53, +1)

No change was recorded against any check on this day. Stability & Change Management went from 3 to 7. That category is still filling its 30-day observation window: 1 days of observed history at the previous scan, 2 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-07-27 (score 52, 0)

- [functional] We updated how we score, so this day's move reflects our rubric, not a change to the server

### 2026-07-26 (score 52)

First indexed and scored.

## MCP tools (32)

### `agent_guide` (~115 tokens)

Agent Guide

Self-serve onboarding: connect any agent (Claude/MCP or REST) to drive the
V12 motor, the same engine the dashboard agent uses. No auth. Returns
copy-paste MCP + REST config with a PLACEHOLDER key, the endpoint map, and the
generate body fields. Operators: issue each user their OWN key via
POST /v1/admin/create-key — never share one key.

\### Responses:

\**200**: Successful Response (Success Response)
Content-Type: application/json

### `health_check` (~62 tokens)

Health

\### Responses:

\**200**: Successful Response (Success Response)
Content-Type: application/json

\**Example Response:**
\```json
{
  "status": "Status",
  "version": "Version",
  "timestamp": "Timestamp"
}
\```

### `health_v12` (~85 tokens)

Health V12

Deep health check for the V12 pipeline. Surfaces:
  \- last nightly regression run (pass/fail + per-slate deltas)
  \- regression baseline metadata
  \- recent preflight blockers (if any cached)
No auth required — monitoring endpoint.

\### Responses:

\**200**: Successful Response (Success Response)
Content-Type: application/json

### `list_slates` (~148 tokens)

Get Slates

List available V12 slates for today. Returns slate IDs, game counts, and lock times.

\### Responses:

\**200**: Successful Response (Success Response)
Content-Type: application/json
\**422**: Validation Error
Content-Type: application/json

\**Example Response:**
\```json
{
  "detail": [
    {
      "loc": [],
      "msg": "Message",
      "type": "Error Type",
      "ctx": {}
    }
  ]
}
\```

Input parameters:

- `compact` (boolean)
- `limit` (integer)
- `playable` (boolean)
- `site` (string)
- `sport` (string)

### `get_slate_players` (~129 tokens)

Get Slate Players Endpoint

Get the V12 player pool for a specific slate ID.

\### Responses:

\**200**: Successful Response (Success Response)
Content-Type: application/json
\**422**: Validation Error
Content-Type: application/json

\**Example Response:**
\```json
{
  "detail": [
    {
      "loc": [],
      "msg": "Message",
      "type": "Error Type",
      "ctx": {}
    }
  ]
}
\```

Input parameters:

- `compact` (boolean)
- `limit` (integer)
- `slate_id` (integer, required)

### `slate_health` (~408 tokens)

Slate Health

Pre-flight diagnostic for a slate. Returns whether odds, projections,
matchup, and FD master-session are ready BEFORE the agent invokes
/v1/generate.

Either slate_id or date is required. When slate_id is given, the slate
metadata is also returned (games list, lock times). When only date is
given, the data-pillar checks still run but game coverage cannot be
computed (returned as null).

READING THE PROJECTION FRESHNESS (MLB especially): `stokastic.age_min` is the
age of the cached snapshot FILE, NOT a data-quality signal. For MLB the cache
is refreshed only twice a day, so mid-afternoon it routinely reads several
hours old AND THAT IS FINE — a user-facing generate fetches projections LIVE
(refresh_data=true), and `stokastic.generate_fetches_live=true` flags this.
A stale `age_min` with a loaded, populated pool is NOT "projections broken /
aces at 0 / no edge": probable pitchers are set days ahead (non-zero), and
only confirmed BATTING lineups firm up ~1-2h before lock. Do NOT treat a stale
cache age as a blocker or tell the user to wait/re-refresh — check the actual
pool (get_slate_players) for non-zero pitcher projections instead.

\### Responses:

\**200**: Successful Response (Success Response)
Content-Type: application/json
\**422**: Validation Error
Content-Type: application/json

\**Example Response:**
\```json
{
  "detail": [
    {
      "loc": [],
      "msg": "Message",
      "type": "Error Type",
      "ctx": {}
    }
  ]
}
\```

Input parameters:

- `date` (string)
- `include_snapshot` (boolean)
- `last_known_fingerprint` (string)
- `site` (string)
- `slate_id` (integer)
- `sport` (string)

### `slate_refresh` (~198 tokens)

Slate Refresh

Re-fetch projections + odds + slate metadata for a date.

Writes to the configured store (Supabase in prod). Returns a summary
dict (date, slate_id, n_games, n_players, n_upserted, n_odds, backend).

Auth: requires X-API-Key OR X-Internal-Secret (cron use). This is a
write op that costs one Stokastic + one ESPN API call.

\### Responses:

\**200**: Successful Response (Success Response)
Content-Type: application/json
\**422**: Validation Error
Content-Type: application/json

\**Example Response:**
\```json
{
  "detail": [
    {
      "loc": [],
      "msg": "Message",
      "type": "Error Type",
      "ctx": {}
    }
  ]
}
\```

Input parameters:

- `date` (string)
- `site` (string)
- `sport` (string)

### `slate_diff` (~350 tokens)

Slate Diff

Compute what changed since a previously-stored snapshot.

Body shape:
  {
    "slate_id": 32867,
    "date": "2026-05-11",
    "sport": "NBA",
    "site": "FD",
    "previous": {
      "v": "v1",
      "players": [{"id","name","status","salary","proj"}, ...],
      "odds":    [{"game","ou","spread","home_ml","away_ml"}, ...]
    }
  }

Returns a structured diff: which players changed status / salary /
projection, which games moved spread or O/U, which players were added
or removed from the pool. The thresholds for "changed":
  \- status: any non-empty difference (Q→OUT, ''→OUT, GTD→IN, etc.)
  \- salary: any integer delta
  \- projection: |delta| >= 0.5 fantasy points
  \- odds spread: |delta| >= 0.5
  \- odds ou: |delta| >= 0.5
  \- odds ml: |delta| >= 10 (American odds noise floor)

No auth required — read-only computation off in-memory current snapshot
plus the caller-supplied previous one.

\### Responses:

\**200**: Successful Response (Success Response)
Content-Type: application/json
\**422**: Validation Error
Content-Type: application/json

\**Example Response:**
\```json
{
  "detail": [
    {
      "loc": [],
      "msg": "Message",
      "type": "Error Type",
      "ctx": {}
    }
  ]
}
\```

### `list_presets` (~148 tokens)

Get Presets

List the available strategy presets (gpp_pro_pattern, gpp_sniper, gpp_balanced, gpp_volume, cash_grinder, gpp_contrarian, gpp_mass_entry) with their configurations. No auth required.

\### Responses:

\**200**: Successful Response (Success Response)
Content-Type: application/json
\**422**: Validation Error
Content-Type: application/json

\**Example Response:**
\```json
{
  "detail": [
    {
      "loc": [],
      "msg": "Message",
      "type": "Error Type",
      "ctx": {}
    }
  ]
}
\```

Input parameters:

- `sport` (string)

### `generate_lineups` (~913 tokens)

Generate Lineups

\### Responses:

\**200**: Successful Response (Success Response)
Content-Type: application/json

\**Example Response:**
\```json
{
  "status": "Status",
  "generated_at": "Generated At",
  "warnings": [],
  "exposures": {},
  "lineups": []
}
\```
\**422**: Validation Error
Content-Type: application/json

\**Example Response:**
\```json
{
  "detail": [
    {
      "loc": [],
      "msg": "Message",
      "type": "Error Type",
      "ctx": {}
    }
  ]
}
\```

Input parameters:

- `allow_locked` (boolean): Explicit replay/late-swap override. Default false blocks slate_id generation once any game has started.
- `avoids` (array): Players to avoid
- `candidate_pool_size` (integer): Exact candidate pool size for Pool→Rank→Keep-N selection. 0/None uses preset multiplier.
- `contest_field_size` (integer): Total entries (field size) of the selected contest. Governs the MLB objective: field <= 10 -> max-mean (mlb_small_field_se); field > 10 -> ceiling (mlb_se_ceiling) with a continuous ceiling tilt and…
- `contest_id` (string): Optional contest handle for building an entry-update CSV from the user's existing contest entries.
- `contest_max_entries` (integer): Max entries per user for the selected contest. Used to identify multi-entry mass GPPs (>=4) which keep the caller's preset. Field SIZE, not this, governs the MLB objective — see contest_field_size.
- `date` (string, required): Slate date YYYY-MM-DD
- `entry_template_csv` (string): Raw CSV of a FanDuel entries-upload-template the operator already downloaded. When present, the entry-upload is filled from its OWN entry_ids locally — no FanDuel API / session / PerimeterX call. Fix…
- `exposure_caps` (object): Per-player exposure caps {name: 0.0-1.0}
- `fd_user_id` (string): DEPRECATED on /v1/generate: fd_user_id is bound server-side to your API key (see /v1/admin/bind-fd-user). Body value is IGNORED on the public route unless X-Internal-Secret matches. Kept on the schem…
- `focus_games` (array): Game keys to emphasize, e.g. ['PHI@BOS']. Applies a small documented projection nudge.
- `lineups` (integer): Number of lineups (overrides preset default)
- `locks` (array): Players to lock in
- `n_sims` (integer): Monte Carlo iterations when simulation is enabled.
- `plan_only` (boolean): When true, the server resolves preset / contest / authoritative slate / top-run-env / locks but does NOT run the optimizer. Returns a Plan response so the user can review and confirm before spending…
- `platform` (string): V12 platform profile: fd or dk.
- `pool_oversample_multiplier` (number): Candidate pool multiplier when candidate_pool_size is not set.
- `preset` (string): Strategy preset key.
- `projection_overrides` (array): User-uploaded projection/ownership rows. Supports name/player_id/team/position/projection/ownership/ceiling/floor/stddev.
- `refresh_data` (boolean): Force a fresh V12 data refresh for user-facing generation. Backtests should set false.
- `runs` (integer): Accepted for tier limits and response metadata. Portfolio quality is controlled by preset, candidate_pool_size, pool_oversample_multiplier, and simulation settings.
- `seed` (integer): Random seed for reproducibility
- `sim_mode` (string): Simulation mode. NBA: mvn/off. MLB: on/off.
- `slate_id` (integer): Specific slate ID from /v1/slates. Overrides date-based lookup.
- `sport` (string): Sport engine to run: nba or mlb.
- `strategy` (string): GPP or cash game strategy
- `style` (string)

### `run_mlb_postmortem` (~328 tokens)

Run Mlb Postmortem

\### Responses:

\**200**: Successful Response (Success Response)
Content-Type: application/json

\**Example Response:**
\```json
{
  "status": "Status",
  "generated_at": "Generated At",
  "date": "Date",
  "game_id": "Game Id",
  "entries": 1,
  "field_lineups": 1,
  "training_rows": 1,
  "missing_sources": [
    "string"
  ],
  "results": {},
  "history_validation": {},
  "field": {},
  "diagnostics": {},
  "simulator_feed": {},
  "warnings": [
    "string"
  ]
}
\```
\**422**: Validation Error
Content-Type: application/json

\**Example Response:**
\```json
{
  "detail": [
    {
      "loc": [],
      "msg": "Message",
      "type": "Error Type",
      "ctx": {}
    }
  ]
}
\```

Input parameters:

- `date` (string, required): Slate date YYYY-MM-DD
- `game_id` (string, required): V12 slate/game handle, e.g. 129715.
- `history_csv` (string, required): Raw FanDuel contest-history CSV content.
- `history_filename` (string)
- `sabersim_csv` (string): Optional external lineup export for comparison.
- `sync_supabase` (boolean): Upsert simulator training rows to production store when configured.
- `top_field_rank` (integer)
- `upload_csvs` (array)

### `list_contests` (~117 tokens)

Contest Registry

List contest strategy registry entries for agents and the dashboard.

\### Responses:

\**200**: Successful Response (Success Response)
Content-Type: application/json
\**422**: Validation Error
Content-Type: application/json

\**Example Response:**
\```json
{
  "detail": [
    {
      "loc": [],
      "msg": "Message",
      "type": "Error Type",
      "ctx": {}
    }
  ]
}
\```

Input parameters:

- `platform` (string)
- `sport` (string)

### `list_live_contests` (~132 tokens)

Live Contests

Return latest V12 contest context without backend identifiers.

\### Responses:

\**200**: Successful Response (Success Response)
Content-Type: application/json
\**422**: Validation Error
Content-Type: application/json

\**Example Response:**
\```json
{
  "detail": [
    {
      "loc": [],
      "msg": "Message",
      "type": "Error Type",
      "ctx": {}
    }
  ]
}
\```

Input parameters:

- `compact` (boolean)
- `limit` (integer)
- `platform` (string)
- `sport` (string)

### `contest_advice` (~176 tokens)

Contest Advice

Advice for a concrete contest name. Resolves the name against the LIVE
lobby FIRST so a real live contest is never reported missing (the curated
registry is only a subset — that was the "$800 Wed MLB Home Run no existe"
bug), then layers registry strategy advice on top when a template matches.

\### Responses:

\**200**: Successful Response (Success Response)
Content-Type: application/json
\**422**: Validation Error
Content-Type: application/json

\**Example Response:**
\```json
{
  "detail": [
    {
      "loc": [],
      "msg": "Message",
      "type": "Error Type",
      "ctx": {}
    }
  ]
}
\```

Input parameters:

- `name` (string, required)
- `platform` (string)
- `sport` (string)

### `fill_template` (~206 tokens)

Fill Template

Fill a downloaded FanDuel/DK entries-template with already-generated
lineups WITHOUT re-running the optimizer — the MCP-callable equivalent of the
dashboard's fill_template. Keeps each entry row's leading columns (entry_id,
contest_id, fee) and replaces the roster-slot columns with a lineup's upload
tokens, cycling lineups if there are more entry rows than lineups.

\### Responses:

\**200**: Successful Response (Success Response)
Content-Type: application/json
\**422**: Validation Error
Content-Type: application/json

\**Example Response:**
\```json
{
  "detail": [
    {
      "loc": [],
      "msg": "Message",
      "type": "Error Type",
      "ctx": {}
    }
  ]
}
\```

Input parameters:

- `lineups` (array, required): Each lineup = upload tokens in template roster-slot order.
- `template_csv` (string, required): Raw CSV of the entries-template (headers + entry rows).

### `admin_issue_key` (~246 tokens)

Issue Key

Idempotently issue a user's API key and ALWAYS return the paste-able
connect block. Returns the email's existing active key (or mints one) so a
user keeps a single key across dashboard reloads; with rotate=true, revokes
the existing keys and mints a fresh one. Admin-gated — the dashboard's
per-user provision route (which verifies the user's Firebase token) calls
this server-side, never the browser.

\### Responses:

\**200**: Successful Response (Success Response)
Content-Type: application/json

\**Example Response:**
\```json
{
  "api_key": "Api Key",
  "tier": "Tier",
  "limits": {}
}
\```
\**422**: Validation Error
Content-Type: application/json

\**Example Response:**
\```json
{
  "detail": [
    {
      "loc": [],
      "msg": "Message",
      "type": "Error Type",
      "ctx": {}
    }
  ]
}
\```

Input parameters:

- `email` (string, required)
- `rotate` (boolean): Revoke existing keys and mint a fresh one.
- `tier` (string)

### `betting_agent_guide` (~48 tokens)

Betting Agent Guide

How any agent uses the MLB betting tools + how to read the output.

\### Responses:

\**200**: Successful Response (Success Response)
Content-Type: application/json

### `betting_player_form` (~122 tokens)

Player Form

Streak / splits / recent form for any player ('racha de X').

\### Responses:

\**200**: Successful Response (Success Response)
Content-Type: application/json
\**422**: Validation Error
Content-Type: application/json

\**Example Response:**
\```json
{
  "detail": [
    {
      "loc": [],
      "msg": "Message",
      "type": "Error Type",
      "ctx": {}
    }
  ]
}
\```

Input parameters:

- `name` (string, required)
- `season` (integer)

### `betting_analyze_prop` (~136 tokens)

Analyze Prop

Model a single player's prop vs tonight's FanDuel line -> edge.

\### Responses:

\**200**: Successful Response (Success Response)
Content-Type: application/json
\**422**: Validation Error
Content-Type: application/json

\**Example Response:**
\```json
{
  "detail": [
    {
      "loc": [],
      "msg": "Message",
      "type": "Error Type",
      "ctx": {}
    }
  ]
}
\```

Input parameters:

- `name` (string, required)
- `prop` (string)
- `season` (integer)
- `threshold` (integer)

### `betting_scan_edges` (~149 tokens)

Scan Edges

Tonight's prop board ranked by model edge (VALUE first).

\### Responses:

\**200**: Successful Response (Success Response)
Content-Type: application/json
\**422**: Validation Error
Content-Type: application/json

\**Example Response:**
\```json
{
  "detail": [
    {
      "loc": [],
      "msg": "Message",
      "type": "Error Type",
      "ctx": {}
    }
  ]
}
\```

Input parameters:

- `coors` (boolean)
- `limit` (integer)
- `min_edge` (number)
- `prop` (string)
- `season` (integer)
- `threshold` (integer)

### `betting_best_bets` (~229 tokens)

Best Bets

THE board sweep — scans EVERY main prop market (HR/RBI/hit/total_bases/
2+hits/stolen_base) in one call and returns the top edges across all of them,
not just home runs. Power props carry the Savant validation (CONFIRMED power
ranked above neutral/noise). Use this for an open 'what's hot / best plays /
what do you recommend tonight' so you NEVER conclude off a single-market scan.
A SCREEN vs the vig line — validate with CLV; game-side value is separate
(betting_sharp / betting_game_model).

\### Responses:

\**200**: Successful Response (Success Response)
Content-Type: application/json
\**422**: Validation Error
Content-Type: application/json

\**Example Response:**
\```json
{
  "detail": [
    {
      "loc": [],
      "msg": "Message",
      "type": "Error Type",
      "ctx": {}
    }
  ]
}
\```

Input parameters:

- `limit` (integer)
- `min_edge` (number)

### `betting_build_parlay` (~170 tokens)

Build Parlay

Correlation-aware analysis of a parlay (>=2 prop legs). Body:
{legs:[{name, prop, threshold}]}. Returns naive vs correlation-adjusted EV,
Kelly stake, and the honest verdict — the parlay-specific edge is the
correlation lift on same-game legs; cross-game parlays are -EV by the vig.

\### Responses:

\**200**: Successful Response (Success Response)
Content-Type: application/json
\**422**: Validation Error
Content-Type: application/json

\**Example Response:**
\```json
{
  "detail": [
    {
      "loc": [],
      "msg": "Message",
      "type": "Error Type",
      "ctx": {}
    }
  ]
}
\```

Input parameters:

- `legs` (array, required)

### `betting_log_bet` (~224 tokens)

Log Bet

Record a bet you placed (per user) so we can track P&L + CLV over time.
Body: {uid, market, selection, odds (American), stake, line?, prop?, team?,
game?, book?}. Append-only — this is the evidence base that PROVES edge.

\### Responses:

\**200**: Successful Response (Success Response)
Content-Type: application/json
\**422**: Validation Error
Content-Type: application/json

\**Example Response:**
\```json
{
  "detail": [
    {
      "loc": [],
      "msg": "Message",
      "type": "Error Type",
      "ctx": {}
    }
  ]
}
\```

Input parameters:

- `book` (string)
- `game` (string)
- `line` (number)
- `market` (string, required)
- `odds` (integer, required)
- `prop` (string)
- `selection` (string, required)
- `stake` (number, required)
- `team` (string)
- `uid` (string, required)

### `betting_my_bets` (~139 tokens)

My Bets

A user's bet history + P&L / CLV summary. avg_clv_pct > 0 over time = you're
beating the closing line = real edge (the only durable proof).

\### Responses:

\**200**: Successful Response (Success Response)
Content-Type: application/json
\**422**: Validation Error
Content-Type: application/json

\**Example Response:**
\```json
{
  "detail": [
    {
      "loc": [],
      "msg": "Message",
      "type": "Error Type",
      "ctx": {}
    }
  ]
}
\```

Input parameters:

- `uid` (string, required)

### `betting_settle_bet` (~168 tokens)

Settle Bet

Settle a logged bet. Body: {uid, bet_id, result: won|lost|push,
closing_odds?}. closing_odds lets us compute CLV (did you beat the close).

\### Responses:

\**200**: Successful Response (Success Response)
Content-Type: application/json
\**422**: Validation Error
Content-Type: application/json

\**Example Response:**
\```json
{
  "detail": [
    {
      "loc": [],
      "msg": "Message",
      "type": "Error Type",
      "ctx": {}
    }
  ]
}
\```

Input parameters:

- `bet_id` (string, required)
- `closing_odds` (integer)
- `result` (string, required)
- `uid` (string, required)

### `betting_cross_book` (~198 tokens)

Cross Book

Cross-book value: FanDuel vs DraftKings (DK pulled via ESPN's public API,
no key/WS). LINE_SHOP (the books hang different numbers — take the easier
side) and PRICE_SHOP (better price, same line) are CONFIRMED edges, no model
needed. Arbitrage is NOT auto-reported (needs over/under sides, which ESPN
doesn't label). Overnight only pitcher_strikeouts overlaps; richer markets
appear near game time.

\### Responses:

\**200**: Successful Response (Success Response)
Content-Type: application/json
\**422**: Validation Error
Content-Type: application/json

\**Example Response:**
\```json
{
  "detail": [
    {
      "loc": [],
      "msg": "Message",
      "type": "Error Type",
      "ctx": {}
    }
  ]
}
\```

Input parameters:

- `prop` (string)

### `betting_game_lines` (~229 tokens)

Game Lines

GAME markets — moneyline / run total / run line for today's MLB games. This
answers the 'quién gana / cuántas carreras / pronóstico Yankees vs Toronto'
questions that player props CAN'T (V12 used to just refuse them). Optional
team filter ('Yankees', 'NYY'). MARKET data from ESPN's public scoreboard,
surfaced as-is — V12 has NO game-outcome model, so this is the book's own
number, never a fabricated prediction. A book may not have posted a game yet
(fields null) — say so, don't invent a line.

\### Responses:

\**200**: Successful Response (Success Response)
Content-Type: application/json
\**422**: Validation Error
Content-Type: application/json

\**Example Response:**
\```json
{
  "detail": [
    {
      "loc": [],
      "msg": "Message",
      "type": "Error Type",
      "ctx": {}
    }
  ]
}
\```

Input parameters:

- `date` (string)
- `team` (string)

### `betting_market` (~239 tokens)

Market

FULL FanDuel market board for a team's game — EVERY market with real odds +
de-vig fair price, so NO market question goes unanswered. Game lines (ML /
total / run line), FIRST 5 INNINGS (F5), TEAM TOTALS, NRFI/YRFI, alternate
lines, AND the full player-prop menu (HR / 2+ HR / hit / 2+ hits / RBI /
2+ RBI / run / single / double / triple / total bases / stolen base / K).
The book's market surfaced as-is (no model). For our model edge on a prop,
follow up with betting_analyze_prop.

\### Responses:

\**200**: Successful Response (Success Response)
Content-Type: application/json
\**422**: Validation Error
Content-Type: application/json

\**Example Response:**
\```json
{
  "detail": [
    {
      "loc": [],
      "msg": "Message",
      "type": "Error Type",
      "ctx": {}
    }
  ]
}
\```

Input parameters:

- `date` (string)
- `team` (string, required)

### `betting_sharp` (~209 tokens)

Sharp

SHARP value — FanDuel vs PINNACLE (the sharpest book, ~2% hold). Pinnacle's
de-vigged line ≈ TRUE probability, so this is the most reliable value signal in
the kit, NO model needed: edge_vs_sharp = FD's price minus the sharp's true
prob; POSITIVE means FanDuel pays MORE than fair (real value vs the market).
Plus total line-shop. Pinnacle only lists UPCOMING games (gone once started).

\### Responses:

\**200**: Successful Response (Success Response)
Content-Type: application/json
\**422**: Validation Error
Content-Type: application/json

\**Example Response:**
\```json
{
  "detail": [
    {
      "loc": [],
      "msg": "Message",
      "type": "Error Type",
      "ctx": {}
    }
  ]
}
\```

Input parameters:

- `date` (string)
- `team` (string, required)

### `betting_game_model` (~223 tokens)

Game Model

MODEL the GAME run markets — TEAM TOTALS (over/under) and NRFI/YRFI — vs the
FanDuel line, with an edge. A run model grounded in real inputs: each team's
season runs/game, the opposing STARTER + BULLPEN run factors, and the park
(team totals = negative-binomial since runs are over-dispersed; NRFI anchored
to the empirical ~0.53 base). A SCREEN vs the market, not a lock — validate
with CLV. For raw lines on every market use betting_market.

\### Responses:

\**200**: Successful Response (Success Response)
Content-Type: application/json
\**422**: Validation Error
Content-Type: application/json

\**Example Response:**
\```json
{
  "detail": [
    {
      "loc": [],
      "msg": "Message",
      "type": "Error Type",
      "ctx": {}
    }
  ]
}
\```

Input parameters:

- `date` (string)
- `team` (string, required)

### `betting_matchup` (~232 tokens)

Matchup

GROUNDING — the real game for a team today: probable pitchers + the POSTED
lineup (ACTUAL player names from MLB statsapi) + the market line + the CONTEXT
a pro reasons with: home-plate UMPIRE (strike zone → totals/Ks), the INJURY
report (who's OUT / Day-To-Day), and BULLPEN health (ERA / blown saves). Call
this BEFORE naming any player or discussing a game. Name ONLY the players this
returns — never a roster from memory (that is how the agent ends up naming
players who aren't on the team).

\### Responses:

\**200**: Successful Response (Success Response)
Content-Type: application/json
\**422**: Validation Error
Content-Type: application/json

\**Example Response:**
\```json
{
  "detail": [
    {
      "loc": [],
      "msg": "Message",
      "type": "Error Type",
      "ctx": {}
    }
  ]
}
\```

Input parameters:

- `date` (string)
- `team` (string, required)

### `betting_market_movers` (~190 tokens)

Market Movers

MARKET pattern (not model opinion): how FanDuel lines MOVED today, from the
captured snapshots. A line that shortened = money coming in (sharp/news); a
drift = money off. This is the 'obvious opportunity' signal — market-confirmed,
independent of our unproven model. Needs accumulated capture; thin → thin.

\### Responses:

\**200**: Successful Response (Success Response)
Content-Type: application/json
\**422**: Validation Error
Content-Type: application/json

\**Example Response:**
\```json
{
  "detail": [
    {
      "loc": [],
      "msg": "Message",
      "type": "Error Type",
      "ctx": {}
    }
  ]
}
\```

Input parameters:

- `date` (string)
- `min_move` (number)
- `prop` (string)

## Diagnostics

Captured diagnostic sections: TLS, DNSSEC, Authorisation, Transports. The full working is on the page: https://verifymcp.io/servers/jorgeperez0825-v12-dfs/v12dfs-production#diagnostics

## Score history

- 2026-08-03: 58
- 2026-08-02: 58
- 2026-08-01: 57
- 2026-07-31: 57
- 2026-07-30: 54
- 2026-07-29: 54
- 2026-07-28: 53
- 2026-07-27: 52
- 2026-07-26: 52

## Links

- Remote endpoint: https://v12dfs-production.up.railway.app/mcp
- Authorisation metadata: https://v12dfs-production.up.railway.app/.well-known/oauth-protected-resource/mcp
- Changelog RSS feed: https://verifymcp.io/servers/jorgeperez0825-v12-dfs/v12dfs-production/changelog.xml
- Changelog JSON feed: https://verifymcp.io/servers/jorgeperez0825-v12-dfs/v12dfs-production/changelog.json
- HTML version of this page: https://verifymcp.io/servers/jorgeperez0825-v12-dfs/v12dfs-production