Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@igaming-odds-mcp What's the margin on a 1.90 / 1.90 market?"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
An MCP server that gives an AI assistant a set of exact, deterministic betting-odds tools: format conversions, bookmaker margin, parlay pricing, bet settlement, and Kelly staking. All the money math is integer-cents and floor-rounded, the same discipline a real settlement ledger uses.
It pairs with a companion project, bet-settlement-service, which settles bets on a double-entry ledger.
convert_odds converts a price between decimal, fractional, American and implied probability. bookmaker_margin works out the overround of a market and the fair odds once the margin is stripped out. parlay_odds combines several legs into one accumulator price. settle_single returns the return and profit in integer cents for a single bet. settle_accumulator settles a multi-leg accumulator, where any losing leg loses the whole bet and void legs drop to 1. settle_each_way settles an each-way bet, win and place parts separately. kelly_stake works out a Kelly-criterion stake for a given edge; a negative edge just recommends no stake at all.
Every input goes through a strict Zod schema, so bad odds (a decimal at or below 1, a probability outside 0 to 1, American at 0) come back as a readable tool error instead of a crash.
Related MCP server: Betting Method MCP Server
pnpm install
pnpm build
pnpm test # 22 tests: pure math + a real MCP handshake over stdioAdd this to claude_desktop_config.json (on macOS that's ~/Library/Application Support/Claude/claude_desktop_config.json):
{
"mcpServers": {
"igaming-odds": {
"command": "node",
"args": ["/absolute/path/to/igaming-odds-mcp/dist/index.js"]
}
}
}Then just ask things like "convert 3/2 to American odds", "what's the margin on a 1.90 / 1.90 market", or "Kelly stake for decimal 2.0 at a true 60% with a $1000 bankroll" and it calls the tools instead of guessing at the math.
Calling bookmaker_margin with decimalOdds [1.9, 1.9] returns:
{
"overround": 1.052632,
"marginPct": 5.2632,
"fairDecimalOdds": [2, 2],
"fairProbabilities": [0.5, 0.5]
}All the logic is pure functions in src/odds.ts; the tool layer only validates input and formats output. Money stays as integer cents and rounding always favors the house, which is asserted in the tests, matching the rule a real settlement engine would follow. Odds convert to exact fractions through a bounded continued-fraction approximation, so something like 1.3333 round-trips to 1/3 instead of some ugly exact decimal.
Compute the overround/margin of a market and the fair odds with it removed.
| Name | Required | Description | Default |
|---|---|---|---|
| decimalOdds | Yes | Decimal odds for every outcome |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must carry the transparency burden. It indicates a pure computation of both margin and fair odds, implying no side effects, but it does not specify the output format or behavior for invalid inputs. This is adequate but not detailed.
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 a single, front-loaded sentence with no wasted words, stating the core computation and output clearly. It is concise without losing essential meaning.
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 simple one-parameter tool with a rich schema, the description adequately conveys what the tool computes and returns. Without an output schema, the mention of margin and fair odds provides sufficient context for the agent to understand the tool's purpose.
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 schema fully documents the single parameter decimalOdds with type, minimum items, and item descriptions. The description adds no extra semantic detail beyond referencing a 'market', so the baseline score of 3 is appropriate given 100% schema 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 uses a specific verb 'Compute' and clearly identifies the resource (overround/margin) and the derived output (fair odds). It is easily distinguishable from siblings like convert_odds or settle_single, which address different betting calculations.
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 implies usage for bookmaker margin analysis but does not explicitly state when to prefer this tool over alternatives or mention any exclusions. The context is clear from the purpose, yet there is no direct decision-making guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Convert a price between decimal, fractional, American and implied probability.
| Name | Required | Description | Default |
|---|---|---|---|
| odds | Yes | The odds value, e.g. 2.5 or "3/2" | |
| format | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It only states the conversion action and formats; it does not mention whether the operation is read-only, what the output format is, or how errors are handled (e.g., invalid odds). The absence of any annotation context means this is a significant gap.
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 a single, focused sentence that conveys the core purpose without redundant words. It is front-loaded with the verb and directly lists the conversion targets.
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 no output schema and no annotations, the description does not explain what the result of the conversion looks like or provide any guidance on edge cases or expected return values. Given the tool's simplicity, a brief mention of the output would improve completeness.
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 schema already enumerates the target formats in the 'format' enum, and the description repeats them in prose without adding meaning (e.g., that 'implied probability' corresponds to the 'probability' enum value, or that 'odds' can be fractional strings like '3/2'). The odds parameter has a schema description, and the description adds no further semantic detail for either parameter.
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 uses the action verb 'Convert' and explicitly names the resource ('a price') and the supported formats (decimal, fractional, American, implied probability). This clearly distinguishes it from siblings like 'settle_single' or 'parlay_odds' which handle betting operations rather than format conversion.
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 implies the tool is for converting odds between formats but does not explicitly state when to use it over alternatives, nor does it note exclusions. The phrase 'Convert a price between...' provides context but lacks explicit guidance such as 'use for odds conversion only' or 'not for settlement calculations.'
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Kelly-criterion stake for an edge; negative edge recommends no stake.
| Name | Required | Description | Default |
|---|---|---|---|
| fraction | No | Fractional-Kelly multiplier | |
| decimalOdds | Yes | Decimal odds, e.g. 2.5 | |
| probability | Yes | Your estimated true win probability | |
| bankrollCents | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the burden. It discloses the negative-edge behavior ('negative edge recommends no stake'), which is useful. However, it does not mention output format, rounding, or how the Kelly fraction interacts with the result.
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 a single, front-loaded sentence with no wasted words. It efficiently conveys the core purpose and a key edge case.
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 simple calculation tool with no output schema, the description is passable but incomplete. It lacks return format (e.g., cents) and details on how fractional Kelly is applied, which are relevant given the parameters.
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 75% (fraction, decimalOdds, probability have descriptions; bankrollCents does not). The description adds the context of 'edge' tying probability and odds together, but does not compensate for bankrollCents or clarify fractional Kelly mechanics.
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 purpose: computing a Kelly-criterion stake. It is specific enough to distinguish from sibling tools like convert_odds or settle_single, though it lacks an explicit verb like 'calculates'.
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?
No guidance is given on when to use this tool over alternatives or what prerequisites are needed. The only contextual hint is the negative-edge rule, which describes behavior, not usage scenarios.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Combine several legs into one accumulator price.
| Name | Required | Description | Default |
|---|---|---|---|
| legs | Yes | Decimal odds per leg |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states 'combine' without explaining the output format, validation of decimal odds, how invalid inputs are handled, or any rounding/pricing behavior. The description gives minimal insight into actual behavior.
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 a single sentence with no filler. Every word contributes to the meaning, and the key action is front-loaded. It is optimally concise.
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?
This is a low-complexity tool with one well-documented parameter, but there is no output schema and no annotations. The description implies the result is an 'accumulator price,' but it does not explicitly state the return type or edge cases. It covers the basic concept but leaves some ambiguity for a simple calculator.
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 coverage is 100%—the 'legs' parameter has a clear description ('Decimal odds per leg') and items description with examples. The tool description adds no additional parameter semantics, so the baseline score of 3 is appropriate given the schema's thorough 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 uses a specific verb 'Combine' and clearly identifies the resource: 'several legs into one accumulator price.' This distinguishes it from siblings like convert_odds, settle_accumulator, or kelly_stake, which handle different betting operations.
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 implies the tool is for combining multiple odds into an accumulator price, but it offers no explicit guidance on when to use it versus alternatives such as convert_odds or settle_accumulator. There are no stated exclusions or comparative context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Settle a multi-leg accumulator; any losing leg loses the bet, void legs drop to 1.
| Name | Required | Description | Default |
|---|---|---|---|
| legs | Yes | ||
| stakeCents | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must carry behavioral disclosure. It does disclose two key behaviors: any losing leg loses the bet and void legs drop to 1. However, it does not mention how push legs are handled, what the return value is, or whether side effects are involved.
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 a single, front-loaded sentence with no filler. It is appropriately concise, though it could be slightly expanded to cover missing behaviors without becoming verbose.
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 no annotations and no output schema, the description should define the settlement outcome and any side effects. It addresses losing and void legs but omits push behavior and the returned value, leaving a significant gap 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?
Schema description coverage is 0%, so the description must compensate. It clarifies that void legs drop to 1, but it never explains stakeCents, the meaning of push, or how decimal odds factor into settlement. This leaves the required parameters under-documented.
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?
Clearly identifies the action (settle) and resource (multi-leg accumulator), distinguishing it from settle_single. It also states the core betting rule, making the purpose unmistakable.
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 phrase 'multi-leg accumulator' clearly sets the use case and differentiates it from single or each-way settlements. It does not explicitly name alternatives, but the context is clear enough for an agent to select this tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Settle an each-way bet (win + place parts); total staked is 2x stakeCents.
| Name | Required | Description | Default |
|---|---|---|---|
| result | Yes | ||
| stakeCents | Yes | ||
| decimalOdds | Yes | Decimal odds, e.g. 2.5 | |
| placeFraction | Yes | Place terms, e.g. 0.25 for 1/4 odds |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must carry the transparency burden. It discloses a key behavioral trait (total staked is 2x stakeCents) and clarifies the two-part nature. However, it does not explain settlement behavior per result (win/place/lose), return values, or whether the operation is a read or write, leaving significant gaps.
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 a single, concise sentence that front-loads the core purpose and adds a critical detail about stake doubling. Every word earns its place with no 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?
Given no output schema and no annotations, the description is too sparse. It does not explain how the win and place parts are settled for each result (win/place/lose), what the function returns, or any side effects. For a settlement tool with 4 parameters, this is a significant completeness gap.
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 coverage is 50% (decimalOdds and placeFraction have descriptions, stakeCents and result do not). The tool description adds meaning to stakeCents by clarifying it is the per-part stake and total is 2x, which is useful. The result parameter's enum values are self-explanatory. Overall, the description partially compensates for schema gaps but does not fully explain all parameters.
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 states the tool settles an each-way bet, explicitly mentioning the win and place parts. This distinguishes it from siblings like settle_single and settle_accumulator. The additional note about total stake being 2x stakeCents further specifies its unique behavior.
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 implies when to use this tool (for each-way bets) but does not explicitly contrast with alternatives or state exclusions. For example, it does not say 'use settle_single for non-each-way bets', so guidance is implicit rather than explicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Return and profit in integer cents for a single bet (floor rounding).
| Name | Required | Description | Default |
|---|---|---|---|
| result | Yes | ||
| stakeCents | Yes | ||
| decimalOdds | Yes | Decimal odds, e.g. 2.5 |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It discloses floor rounding and integer-cent output, which are useful behavioral traits. However, it fails to specify how push/void outcomes are handled (e.g., stake returned, zero profit) or the profit formula, leaving ambiguity for edge cases.
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 a single, front-loaded sentence that conveys the core purpose with no unnecessary words. Every element contributes to understanding.
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?
There is no output schema, so the description must explain the return format and per-outcome behavior. It only states 'return and profit in integer cents' without indicating whether the output is a tuple, object, or how push/void map to outputs, making the tool difficult to invoke 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 only 33%, with only decimalOdds described. The tool description adds no parameter-specific meaning beyond what is already apparent from the schema (e.g., stakeCents is in cents, result enum). It does not explain how the parameters relate to the computed return and profit.
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 states the tool computes return and profit in integer cents for a single bet with floor rounding. The verb 'return' and resource 'single bet' distinguish it from sibling tools like settle_accumulator and settle_each_way.
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 phrase 'single bet' implies the tool is for single-bet settlement, giving some context. However, it does not explicitly contrast with alternatives like settle_accumulator or settle_each_way, nor does it provide when-not-to-use guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
v0.1.0bookmaker_marginconvert_oddskelly_stakeparlay_oddssettle_accumulatorsettle_each_waysettle_singleScored across 7 tools
Each tool targets a distinct betting/odds concept: conversion, margin, parlay construction, three settlement types, and stake sizing. The settle_* tools are clearly separated by bet structure, and the others are unambiguously different operations.
Most tools follow a verb_noun pattern (convert_odds, settle_single, parlay_odds), but bookmaker_margin and kelly_stake are noun phrases, breaking the uniformity. The naming is readable and lowercase with underscores, but the pattern is not fully consistent.
Seven tools is well-scoped for an igaming/odds toolkit, covering core operations without redundancy. Each tool serves a clear purpose and the count is comfortably within the ideal range.
The toolset covers the full lifecycle of odds manipulation and bet settlement: conversion, margin calculation, parlay building, single/accumulator/each-way settlement, and stake recommendation. No critical gaps are apparent for the stated domain.
The Odds API MCP — sportsbook odds across 70+ books, 30+ leagues
Sports Game Odds MCP — wraps the Sports Game Odds API (sportsgameodds.com)
Sportsbook-derived no-vig fair value with confidence, provenance, and history over REST/MCP.
MCP server with quote and live cryptocurrency price tools, local and cloud-deployed transports.
