Which integrations are available for this server?

Provides calibrated win-rate predictions, hero lookups, counter recommendations, and draft recommendations for Dota 2 matches.

How do I use batru-mcp?

1. Click on "Install Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@batru-mcp predict Dota 2 win rate for PA, Lina vs Sniper, Pudge" 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.

batru-mcp

by batrugg

Overview Schema Source Related Servers Score Discussions Admin

Python

Remote

batru-mcp

IMPORTANT

Use the hosted endpoint — no install needed. Add https://batru.gg/mcp to Claude, ChatGPT, Cursor or any MCP client and you get the newest tool set (31 read-only tools across Dota 2, Deadlock and Marvel Rivals, always in sync with the live site). Setup guide: https://batru.gg/developers

The local PyPI package described below (uvx batru-mcp) is legacy and no longer updated — it is frozen at an early version with a reduced tool set. It still works (it proxies the same live API), but the hosted endpoint is the canonical distribution.

A minimal, read-only MCP server over batru.gg's live API, so your LLM can answer Dota 2 / Deadlock draft, counter and win-rate questions with real, calibrated model predictions instead of guessing from memory.

It is a thin wrapper around batru.gg's public endpoints — no model runs locally; every number comes from the same production model the website serves.

Why calibrated matters

batru.gg's model is trained on ~20M real matches and calibrated: a reported 60% win rate corresponds to an empirically observed ~60% win rate. We deliberately do not headline a raw "accuracy" number — accuracy alone is misleading for win prediction. What you get from these tools are probabilities you can trust at face value. The tool descriptions instruct the host LLM to report these numbers verbatim and never invent matchup data.

Related MCP server: Valorant MCP Server

Tools

Tool	What it does
`lookup_hero(query, game="dota2")`	Normalise a name/alias/shortName to `{id, displayName, shortName}`. `game` ∈ {`dota2`, `deadlock`}.
`predict_dota_winrate(my_heroes, enemy_heroes, my_side="radiant")`	Calibrated win-rate % for both teams (partial drafts OK; empty → 50/50).
`recommend_dota_pick(my_heroes, enemy_heroes, my_side="radiant")`	Top-3 heroes to pick next, each with its calibrated win rate.
`get_dota_counters(hero, limit=12)`	Real matchup table: who this hero beats / loses to, with win rate % and sample size.
`predict_deadlock_draft(team0_heroes, team1_heroes)`	Calibrated win-rate % for a Deadlock 6v6 (6 heroes per team).

Hero names are accepted in any form (e.g. am, anti mage, Anti-Mage) and normalised internally — the backend silently drops names it doesn't recognise, so normalising first keeps predictions honest.

Install

Requires uv (or any way to run a Python 3.12+ package from PyPI):

uvx batru-mcp           # fetches from PyPI and starts the stdio MCP server

Configuration is via the BATRU_API_BASE environment variable (default https://batru.gg) — you normally don't need to set anything.

Claude Desktop config

Add to claude_desktop_config.json (macOS: ~/Library/Application Support/Claude/claude_desktop_config.json):

{
  "mcpServers": {
    "batru": {
      "command": "uvx",
      "args": ["batru-mcp"]
    }
  }
}

Restart Claude Desktop; the batru tools appear in the tool picker. Claude Code: claude mcp add batru -- uvx batru-mcp.

Development

git clone https://github.com/batrugg/batru-mcp && cd batru-mcp
uv sync
uv run batru-mcp        # run the server from the checkout (blocks, waiting on stdin)

For a Claude Desktop pointing at the checkout, use "command": "uv", "args": ["run", "--directory", "/absolute/path/to/batru-mcp", "batru-mcp"].

Tests

uv run pytest            # offline: hero normalisation + draft assembly
uv run pytest -m live    # also hits the real batru.gg API

Prefer programmatic access from Python instead of MCP? pip install batru — the official batru SDK.

Available Tools

5 tools

get_dota_countersAInspect

Get the strongest matchups (counters) for a Dota 2 hero from real games.

Returns opponents this hero performs BEST and WORST against, by real observed matchup win rate (with sample sizes). This is empirical meta data from batru.gg's match aggregation, not a guess. The hero name is normalised internally.

Args: hero: The hero to look up (name/alias/shortName). limit: Max number of matchups to return (default 12).

Returns {hero, best_against:[...], worst_against:[...]} where each row has {opponent, winrate_pct, matches}. winrate_pct > 50 means hero beats that opponent. Report numbers verbatim.

ParametersJSON Schema

Name	Required	Description	Default
`hero`	Yes
`limit`	No

TDQS

A4.8/5.0

Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description fully covers behavior: it uses empirical data from real games, normalizes hero names, and returns win rates with sample sizes. It is honest about being a read-only lookup and explains the meaning of winrate_pct.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is concise and well-structured: a summary line, then explanation of best/worst, then Args and Returns sections. Every sentence adds value without redundancy.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Despite lacking an output schema, the description fully defines the return object shape and field meanings, including how to interpret winrate_pct. All parameters are covered, and the tool's context is clear.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters5/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 0% (no descriptions in JSON Schema), but the description compensates by explaining both parameters: hero accepts name/alias/shortName, and limit defaults to 12. It adds meaning beyond the schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's purpose: 'Get the strongest matchups (counters) for a Dota 2 hero from real games.' It uses a specific verb and resource, and the distinction from sibling tools like 'lookup_hero' or 'predict_dota_winrate' is evident.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description explains what the tool returns and advises to 'Report numbers verbatim,' implying usage context. However, it does not explicitly state when not to use this tool or compare it with alternatives.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

lookup_heroAInspect

Normalise a hero name/alias/shortName to its canonical identity.

Use this to turn messy user input ("am", "anti mage", "Anti-Mage") into the exact key batru.gg expects before calling the prediction tools. The backend SILENTLY DROPS hero names it doesn't recognise, so always normalise first.

Args: query: A hero name, alias, or short name. game: "dota2" (default) or "deadlock".

Returns {id, displayName, shortName, game} for the best match, or an error with did_you_mean candidates if nothing matches.

ParametersJSON Schema

Name	Required	Description	Default
`game`	No		dota2
`query`	Yes

TDQS

A4.5/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Discloses that backend silently drops unrecognized names and that this tool prevents that. Describes return fields (id, displayName, shortName, game) and error with did_you_mean. No contradictions; no annotations provided.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Concise yet complete: one-sentence summary, usage guideline, technical details, and structured Args/Returns. Every sentence adds value. Front-loaded with purpose.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given no output schema, description explains return structure and error case. Covers game parameter values, silent drop behavior, and use case. Fully addresses tool complexity.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema has 0% description coverage, so description carries full burden. It describes 'query' as 'A hero name, alias, or short name' and 'game' as 'dota2 (default) or deadlock'. Adds concrete meaning beyond raw schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

Description clearly states it normalizes a hero name/alias/shortName to canonical identity. Gives examples ('am', 'anti mage'). Distinguishes from sibling prediction tools by positioning it as a preprocessing step before calling them.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Explicitly says to use this tool to turn messy input into exact key expected by prediction tools. Emphasizes always normalizing first because backend silently drops unrecognized names. Does not mention when not to use or alternatives.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

predict_deadlock_draftAInspect

Predict the CALIBRATED win probability for a Deadlock 6v6 draft.

Backed by batru.gg's Deadlock production model. Provide 6 heroes per team (names are normalised to Deadlock hero ids internally). A reported 60% reflects a real ~60% empirical win rate — it is calibrated, not a guess.

Args: team0_heroes: Team 0's 6 heroes (names/aliases). team1_heroes: Team 1's 6 heroes (names/aliases).

Returns calibrated win-rate percentages for both teams. Report verbatim.

ParametersJSON Schema

Name	Required	Description	Default
`team0_heroes`	Yes
`team1_heroes`	Yes

TDQS

A4.2/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden. It explains that the prediction is 'calibrated' (not a guess) and instructs to 'Report verbatim' for the returned win-rate percentages. It also notes internal hero name normalization. This provides good behavioral context, though rate limits or error cases are not discussed.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is concise and well-structured: a lead sentence stating the core function, a supporting sentence about calibration and model source, then explicit parameter documentation, and a final note on return values. Every sentence adds value without redundancy.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's complexity (6 heroes per team, calibrated model), the description covers purpose, input requirements, and output nature. It lacks details on error handling or invalid inputs, but for a straightforward prediction tool, it is largely complete.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 0%, so parameters lack descriptions in the schema. The description explicitly documents both parameters (team0_heroes, team1_heroes) as 'Team 0's 6 heroes (names/aliases)' and similarly for team1, adding meaning beyond the schema's array type. This compensates well for the low coverage.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states it predicts 'calibrated win probability for a Deadlock 6v6 draft', using specific verb 'predict' and resource 'win probability'. It distinguishes itself from sibling tools (e.g., predict_dota_winrate) by specifying Deadlock context.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description mentions 'Provide 6 heroes per team' and 'Backed by batru.gg's Deadlock production model', implying use for Deadlock drafts. However, it does not explicitly state when not to use or compare with alternatives, leaving usage context implied.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

predict_dota_winrateAInspect

Predict the CALIBRATED win rate for a Dota 2 draft.

Backed by batru.gg's production model (trained on ~20M real matches and calibrated, so a reported 60% reflects a real ~60% empirical win rate — it is not a guess). Partial drafts are fine; an empty draft returns 50/50. Hero names are normalised internally to shortNames.

Args: my_heroes: Your team's heroes (names/aliases, 0-5). enemy_heroes: Enemy heroes (names/aliases, 0-5). my_side: "radiant" (default) or "dire" — which side is "my_heroes".

Returns calibrated win-rate percentages for both teams. Report these numbers verbatim; do not adjust them.

ParametersJSON Schema

Name	Required	Default
`my_side`	No	radiant
`my_heroes`	Yes
`enemy_heroes`	Yes

TDQS

A4.8/5.0

Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations provided, so description carries full burden. It discloses calibration (model is calibrated so reported numbers are empirical), that hero names are normalised, partial drafts supported, and that returns should be reported verbatim. This is thorough behavioral context.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is concise: a clear opening sentence, then a paragraph of important context, and a bullet-like Args section. Every sentence adds value; no redundancy or fluff.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given 3 parameters, no output schema, and no annotations, the description fully covers inputs, behavior, calibration, and return instructions. It answers likely agent questions about partial drafts, empty drafts, and output handling.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters5/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 0%, but the description explains each parameter in detail: my_heroes and enemy_heroes are arrays of hero names/aliases (0-5), my_side defaults to 'radiant' and specifies which side is my_heroes. This adds full meaning beyond the schema's minimal title and type.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states 'Predict the CALIBRATED win rate for a Dota 2 draft.' It specifies the exact action (predict), resource (Dota 2 draft), and adds nuance (calibrated). Siblings like lookup_hero or recommend_dota_pick are distinct, making this tool's purpose unambiguous.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description explains when to use the tool (e.g., for draft win rate prediction), notes that partial drafts are fine and empty draft returns 50/50. However, it does not explicitly contrast with siblings or state when not to use it. The sibling names provide context but the description itself could be more explicit.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

recommend_dota_pickAInspect

Recommend the top 3 Dota 2 heroes to pick next, with calibrated win rates.

Backed by batru.gg's production model. Each suggestion comes with the CALIBRATED win rate your team would have after adding that hero against the given enemy draft (a reported 60% reflects a real ~60% empirical win rate). Hero names are normalised internally.

Args: my_heroes: Heroes your team has already picked (names/aliases, 0-4). enemy_heroes: Enemy heroes (names/aliases, 0-5). my_side: "radiant" (default) or "dire" — which side is "my_heroes".

Returns a list of up to 3 {displayName, shortName, win_rate_pct}. Report the win rates verbatim.

ParametersJSON Schema

Name	Required	Default
`my_side`	No	radiant
`my_heroes`	Yes
`enemy_heroes`	Yes

TDQS

A4.4/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries full burden. It discloses calibrated win rates, internal normalization, and return format. It does not mention any destructive actions or error conditions, but is reasonably transparent.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Description is well-structured with a lead sentence, context, and clear Args section. It is concise and front-loaded with main purpose. Every sentence adds value.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given 3 parameters, no output schema, and sibling tools, the description is fairly complete. It explains what, how, and output. Lacks explicit when-not-to-use, but overall sufficient.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, but the description compensates by explaining each parameter: my_heroes (names/aliases, 0-4), enemy_heroes (0-5), my_side with default. It adds meaning beyond the schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool recommends the top 3 Dota 2 heroes to pick next, with calibrated win rates. It uses specific verb and resource, and differentiates from siblings like predict_dota_winrate and get_dota_counters.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides context on parameters and return format, but does not explicitly state when to use this tool vs alternatives or when not to use it. The Args section helps, but no direct exclusions.

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.

5 tool updatesv0.1.2Jul 29, 2026
- First observedget_dota_counters
- First observedlookup_hero
- First observedpredict_deadlock_draft
- First observedpredict_dota_winrate
- First observedrecommend_dota_pick

Install Server

RayrunBuild, deploy, and operate MCP servers without becoming an infrastructure team.ray.runAd

TDQS

A4.5/5.0

Scored 2026-07-29 20:35 across 5 tools

Disambiguation5/5

Each tool serves a clearly distinct purpose: hero normalization, Dota win rate prediction, Dota pick recommendation, Dota matchup analysis, and Deadlock draft prediction. No overlap or ambiguity.

Naming Consistency5/5

All tools follow a consistent verb_noun pattern using snake_case (e.g., lookup_hero, predict_dota_winrate, recommend_dota_pick). Minor verb variation is expected and does not break consistency.

Tool Count5/5

With 5 tools covering core analytics for two games, the count is well-scoped. Each tool adds unique functionality without redundancy or unnecessary weight.

Completeness4/5

For Dota 2, the toolset covers hero identification, match win rate, pick recommendations, and counters—comprehensive for prediction. Missing hero stats or item analysis, but these are beyond the defined scope. Deadlock is only covered by one prediction tool, but that aligns with the server's focus.

Maintenance

ActivityMaintained

ResponsivenessNo issues

Resources

Need Help?

Related Servers

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Related MCP Connectors

Parlay AOAuth
run.parlay
Read-only MCP server for live Polymarket, Kalshi, Limitless odds; Manifold sentiment.
Finance Research & Data
626
Opendota A
io.github.pipeworx-io
OpenDota MCP — Dota 2 open stats.
Games & Gamification Open Data
352
Stratz B
io.github.pipeworx-io
STRATZ Dota 2 MCP.
Games & Gamification Sports
432
helldivers2-mcp A
io.github.xerno42
MCP server exposing live Helldivers 2 galactic war data.
Games & Gamification Entertainment & Media
722

Related MCP Servers

OpenDota MCP Server
Games & Gamification Search Data Platforms
asusevski
A
license
B
quality
C
maintenance
Model Context Protocol server that enables LLMs and AI assistants to retrieve real-time Dota 2 statistics, match data, player information, and game metrics through a standardized interface.
Updated a year ago (2025-10-16 17:30 UTC)
17
8
MIT
Valorant MCP Server
SeijiMatsumoto
F
license
Not graded
quality
D
maintenance
MCP server for Valorant match analysis. Enables fetching player stats, match history, agent performance, and more via Henrik's Valorant API.
Updated 4 months ago (2026-05-06 22:15 UTC)
-
ValorLens
Sports Databases Data Platforms
saphire112211
A
license
Not graded
quality
C
maintenance
MCP server for Valorant esports analytics that exposes structured metrics and database query tools, enabling AI-assisted match analysis, player profiling, scouting reports, and coaching insights.
Updated a month ago (2026-08-05 16:22 UTC)
Apache 2.0
liquipedia-dota2-mcp
Sports Open Data
Mooooooon
A
license
A
quality
C
maintenance
Read-only MCP server for sourced Dota 2 tournament, team, player, schedule, and result data from Liquipedia, with revision-level metadata and caching.
Updated 25 days ago (2026-08-16 16:25 UTC)
5
9
MIT