Skip to main content
Glama

chess-coach-mcp

PyPI CI Python 3.11+ License: MIT

A hybrid AI chess coach exposed as an MCP server. A local Stockfish engine supplies grounded evaluations, mistake classifications and tactical motifs; your MCP host model (e.g. Claude) turns those facts into natural-language — Korean or English — coaching.

The engine knows what the best move is. The model explains why. This project wires the two together and adds the piece neither does alone: "here is your recurring mistake, drilled from your own games."

pip install chess-coach-mcp      # or: uvx chess-coach-mcp   (needs a local Stockfish)

See it in action

diagnose_weaknesses turns your recent games into a weakness report — recurring tactical blind spots and where you lose the most (by phase):

…then recommend_drills hands back the exact positions you went wrong in — your move in red, the engine's in green — so you re-solve your own mistakes:

Numbers above are real Stockfish output; the weakness report uses an example dataset. Regenerate everything with uv run --with matplotlib --with pillow python docs/generate_assets.py.

Related MCP server: Chess MCP

Why this exists

Engines (Stockfish) tell you the best move but not the reason. Raw LLMs explain fluently but play/evaluate chess poorly and hallucinate lines. Existing trainers are fragmented (one app for stats, one for explanations, one for courses) and rarely give a personalised, guided path. chess-coach-mcp is the grounding layer: every claim the coach makes is backed by Stockfish, and the weakness diagnosis is computed from the player's actual games.

What it does

  • Fetch recent games from Lichess or Chess.com (public APIs, no key).

  • Analyse a game: per-move classification (best / good / inaccuracy / mistake / blunder, with Korean labels), win% before/after, centipawn loss, the engine's preferred move, tactical-motif tags, and per-phase summary.

  • Analyse a position (FEN): top engine lines in SAN, win%, material, and fork/pin flags — so the model can explain the why.

  • Diagnose weaknesses across many games: phase weaknesses (opening/middlegame/endgame), recurring tactical blind spots with example positions, leaky openings, a time-trouble proxy, and a ranked top-weakness list.

  • Recommend drills: re-solvable positions taken from the player's own blunders, ordered to target their top weaknesses, plus a Lichess daily puzzle warm-up.

What makes it different (차별점)

Most chess tools do one thing well, so you end up stitching several together. chess-coach-mcp is the missing grounding + personalisation layer, delivered right where you already work — inside your AI assistant.

chess-coach-mcp

Stockfish alone

DecodeChess

Aimchess

Chessable

Best move (what)

Explains the why in prose

Personal weakness diagnosis across your games

Drills from your own blunders

Korean (bilingual) coaching

Local / private (your engine, no account)

❌ cloud

❌ cloud

❌ cloud

Lives inside your AI assistant (MCP)

Cost

free, OSS

free

subscription

subscription

paid courses

The five things that set it apart:

  1. Hybrid & grounded — Stockfish is the judge, the LLM is the explainer. Every coaching claim is backed by the engine, so there are no hallucinated evaluations or made-up lines (the failure mode of asking a raw LLM about chess).

  2. Personal, not genericdiagnose_weaknesses aggregates your games into phase weaknesses, recurring tactical blind spots and leaky openings; recommend_drills quizzes you on your own blunder positions — not random puzzles at your rating.

  3. Bilingual EN/KO — every structured fact carries a Korean label, so the coaching reads naturally in Korean (한국어 코칭).

  4. Local-first & private — your own Stockfish binary + public read-only APIs. No account, no API key, nothing about your games is uploaded anywhere.

  5. Inside your assistant — it's an MCP server, so coaching happens in the same chat you already use, composable with everything else your assistant can do.

Tools

Tool

Purpose

engine_status

Check the local Stockfish binary is available.

render_board(fen, orientation)

Show a position as a text board + Lichess link (no engine).

fetch_recent_games(username, source, max_games, speed)

List recent games (no analysis).

analyze_position(fen, depth, multipv)

Evaluate one position; top lines + flags.

analyze_game(pgn, depth, user_color, max_plies)

Full per-move game review.

diagnose_weaknesses(username, source, max_games, depth, speed)

Cross-game weakness report.

recommend_drills(username, source, max_games, depth, num_drills, include_daily_puzzle)

Personalised drill set.

source is lichess (default) or chesscom. Every numeric/categorical fact ships with a *_ko Korean label for natural Korean coaching. Positions in tool output also carry a board_ascii text board and a lichess_url, so the coach can draw the board right in the chat or link you to an interactive one.

Does a board show up in chat?

This is an MCP server: it returns data (FENs, evaluations, a board_ascii text board, a lichess_url), and your assistant turns that into coaching. So a graphical board doesn't pop up by itself — but the model can print the board_ascii board in any client, you can click the lichess_url for a real interactive board, and on claude.ai the model can draw an SVG board from the FEN. (The demo GIF above is a generated README asset, not the live chat UI.)

Requirements

  • Python ≥ 3.11

  • Stockfish on your PATH (or set STOCKFISH_PATH):

    • macOS: brew install stockfish

    • Debian/Ubuntu: apt install stockfish

Install & run

From PyPI:

pip install chess-coach-mcp
chess-coach-mcp               # run the MCP server over stdio
# …or run without installing:
uvx chess-coach-mcp

From source:

uv sync                      # install dependencies
uv run chess-coach-mcp       # run the MCP server over stdio

Register with Claude Code

claude mcp add chess-coach -- uv --directory /ABS/PATH/TO/chess-coach-mcp run chess-coach-mcp

Or add to an MCP client config:

{
  "mcpServers": {
    "chess-coach": {
      "command": "uv",
      "args": ["--directory", "/ABS/PATH/TO/chess-coach-mcp", "run", "chess-coach-mcp"],
      "env": { "STOCKFISH_PATH": "/opt/homebrew/bin/stockfish" }
    }
  }
}

Example coaching flow

"내 리체스 약점 좀 진단해줘. 아이디 myname."

The host calls diagnose_weaknesses("myname"), gets back per-phase ACPL, recurring motifs (e.g. hanging_piece ×4, missed_tactic ×3) with example FENs, then explains in Korean why those positions went wrong and calls recommend_drills("myname") to quiz the user on their own blunders.

Configuration (environment variables)

Variable

Default

Meaning

STOCKFISH_PATH

autodetect

Path to the Stockfish binary.

CHESS_COACH_ENGINE_THREADS

1

Engine threads.

CHESS_COACH_ENGINE_HASH_MB

128

Engine hash size (MB).

CHESS_COACH_POSITION_DEPTH

16

Default depth for analyze_position.

CHESS_COACH_GAME_DEPTH

14

Default depth for analyze_game.

CHESS_COACH_DIAGNOSE_DEPTH

12

Default depth for diagnosis (lower = faster).

How move classification works

Moves are classified by the drop in win percentage, not raw centipawns, using Lichess' logistic model — far more meaningful in already-winning or already-losing positions. A move is a blunder if it loses ≥20% win probability, a mistake at ≥10%, an inaccuracy at ≥5%. Mate-aware: a move that throws away a forced mate or walks into one is flagged accordingly.

Tactical motifs are heuristic labels (depth-1 static exchange for hanging pieces, geometric detection for forks/pins/back-rank). They exist to group engine-found mistakes into human themes, not to replace the engine's judgement.

Development

uv run pytest                       # unit + engine tests (skips engine tests if no Stockfish)
uv run python examples/mcp_smoke.py # boot the server over MCP and call tools
uv run python examples/live_check.py <lichess_username>  # live network E2E

Tests marked engine require a Stockfish binary; live tests (none by default) hit the network and are deselected unless you pass -m live.

License

MIT

Available Tools

6 tools
analyze_gameA

Analyse a full game from PGN: per-move classification + motifs + summary.

Each move gets a classification (best/good/inaccuracy/mistake/blunder with
Korean labels), win% before/after, centipawn loss, the engine's preferred
move, and tactical-motif tags. The summary gives per-side accuracy/ACPL,
per-phase breakdown, and the worst moments (with FENs for drilling).

Set user_color to 'white' or 'black' to focus the worst-moment and motif
reporting on one player.
ParametersJSON Schema
NameRequiredDescriptionDefault
pgnYes
depthNo
user_colorNo
max_pliesNo

TDQS

A4.1/5.0
Behavior4/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 the tool's output: per-move classification, win% before/after, centipawn loss, engine's preferred move, tactical-motif tags, per-side accuracy/ACPL, per-phase breakdown, and worst moments with FENs. It does not mention destructive actions or auth needs, which are safe to assume absent.

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

Conciseness4/5

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

The description is a single paragraph, front-loaded with purpose, then details, then usage. It is informative but not overly verbose. Could be slightly more structured with bullet points.

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 complexity of full game analysis, the description covers the main outputs comprehensively. No output schema exists, so the description must detail return values, which it does. It does not mention error handling or PGN format requirements.

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

Parameters3/5

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

Schema coverage is 0%, so description must compensate. It explains pgn (required) and user_color (to focus reporting). However, depth and max_plies are not described beyond default values. Partial compensation.

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 analyzes a full game from PGN, providing per-move classification with Korean labels, win% changes, centipawn loss, engine moves, tactical motifs, and a summary with accuracy/ACPL and per-phase breakdown. This differentiates it from siblings like analyze_position (likely single position) and diagnose_weaknesses (post-analysis).

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 that setting user_color focuses reporting on one player. It implies the tool is for analyzing a full game, but does not explicitly state when not to use or list alternatives. However, the sibling context provides differentiation.

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

analyze_positionA

Evaluate a single position (FEN) and return the top engine lines.

Returns evaluation in centipawns and win%, the best lines in SAN, material
balance, and simple tactical flags (fork threats, pins). Use this to explain
*why* a move is best in a specific position.
ParametersJSON Schema
NameRequiredDescriptionDefault
fenYes
depthNo
multipvNo

TDQS

A4.1/5.0
Behavior4/5

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

No annotations provided, so the description carries the full burden. It discloses expected outputs: centipawns, win%, SAN lines, material, tactical flags. It does not mention side effects or constraints, but the description is transparent about what the tool does and returns.

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 three sentences, front-loaded with action and returns, with no wasted words. It is efficiently structured and easy to scan.

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 no output schema and no annotations, the description covers the main outputs and use case. It lacks some details like limits or prerequisites, but is fairly complete for a straightforward analysis tool.

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

Parameters2/5

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

Schema description coverage is 0%, and the description does not explain individual parameters like depth or multipv. It mentions 'FEN' implicitly but lacks details on parameter meaning or defaults.

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 evaluates a single position (FEN) and returns engine lines, evaluation, material balance, and tactical flags, distinguishing it from sister tools like analyze_game which likely analyzes entire games.

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 explicitly says 'Use this to explain *why* a move is best in a specific position,' providing clear context for when to use. It does not contrast with siblings, but the guidance is sufficient.

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

diagnose_weaknessesA

Diagnose a player's recurring weaknesses across their recent games.

Fetches recent games, analyses each from the player's perspective, and
aggregates: overall accuracy/ACPL, per-phase (opening/middlegame/endgame)
breakdown, recurring tactical blind spots (with example positions), leaky
openings, a time-trouble proxy, and a ranked list of top weaknesses with
example FENs. This is the core 'coach' tool — heavier (runs the engine over
many games), so keep max_games modest for fast turnaround.
ParametersJSON Schema
NameRequiredDescriptionDefault
usernameYes
sourceNolichess
max_gamesNo
depthNo
speedNo

TDQS

A4.1/5.0
Behavior4/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 that the tool runs engine analysis over many games, is computationally heavy, and suggests limiting max_games. It lists output components. It does not mention auth needs or rate limits, but the behavioral impact (heavy) is clearly conveyed.

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 very concise at three sentences. It front-loads the purpose, then details the rich output, and ends with usage guidance. Every sentence adds value with no waste.

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 no output schema, the description covers return values (accuracy, per-phase breakdown, tactical blind spots with FENs, etc.) adequately. It doesn't specify format or error conditions, but for a coach tool, the level of detail is sufficient for an agent to understand what to expect.

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

Parameters2/5

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 only addresses max_games ('keep max_games modest') but does not explain username, source, depth, or speed. Users are left to infer these from the tool name and common sense, which is insufficient for correct invocation.

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 diagnoses recurring weaknesses from recent games, with specific outputs (accuracy, per-phase, blind spots, etc.). It distinguishes itself from siblings like analyze_game (single game) and fetch_recent_games (just fetch) by emphasizing the aggregation over multiple games.

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 guidance on when to use ('core coach tool') and a practical constraint ('keep max_games modest for fast turnaround'). It implies this is heavier than other tools, so alternatives like analyze_game are better for single-game analysis, though not explicitly stated.

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

engine_statusA

Report whether the local Stockfish engine is available and its version.

Call this first if other tools fail with an engine error.

ParametersJSON Schema
NameRequiredDescriptionDefault

No parameters

TDQS

A4.3/5.0
Behavior3/5

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

With no annotations provided, the description covers basic behavior (read-only status check) but does not add details like non-destructive nature or specific conditions.

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 two sentences with only 20 words, front-loading the purpose and adding a usage hint without any 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?

For a simple, parameterless status-check tool with no output schema, the description thoroughly covers purpose and usage context.

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?

The input schema has zero parameters and 100% schema coverage, so no param info is needed. The description is adequate given the absence of parameters.

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 reports the availability and version of the local Stockfish engine, distinguishing itself from sibling tools that analyze games or positions.

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 second sentence explicitly advises to call this tool first if other tools fail with an engine error, providing clear when-to-use context, though no exclusions are mentioned.

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

fetch_recent_gamesA

Fetch a player's recent games from Lichess or Chess.com (public data).

source: 'lichess' or 'chesscom'. speed (optional) filters by
bullet/blitz/rapid/classical. Returns normalised game records including PGN,
players, ratings, result and opening. No analysis is run here.
ParametersJSON Schema
NameRequiredDescriptionDefault
usernameYes
sourceNolichess
max_gamesNo
speedNo

TDQS

A3.7/5.0
Behavior3/5

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

Without annotations, the description adds value by stating 'No analysis is run here' and mentions public data, but fails to disclose any side effects, rate limits, or read-only guarantee. It partially compensates for missing annotations.

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 with three sentences, front-loading the purpose and efficiently covering essential details without extraneous text.

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

Completeness3/5

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

The tool has 4 parameters and no output schema. The description lists return fields but lacks structure (array vs object) and omits explanation for 'username' and 'max_games'. It meets minimum completeness but has gaps.

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

Parameters3/5

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

Schema coverage is 0%, so description must explain parameters. It explains 'source' and 'speed' with acceptable detail, but 'max_games' and 'username' are not described, leaving gaps. The description provides some added meaning over 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 verb 'Fetch', the resource 'player's recent games', and the sources 'Lichess or Chess.com', distinguishing it from sibling tools like 'analyze_game' which perform analysis.

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 implies usage for fetching game data but does not explicitly state when to use this tool versus alternatives (e.g., for raw data vs analysis). It also lacks prerequisites or exclusions.

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

recommend_drillsA

Build a personalised drill set from the player's own mistakes.

Runs diagnose_weaknesses, then returns re-solvable drill positions taken
from the player's actual blunders (FEN, side to move, the engine's preferred
move as the answer), ordered to target their top weaknesses, plus an
optional Lichess daily puzzle as a warm-up.
ParametersJSON Schema
NameRequiredDescriptionDefault
usernameYes
sourceNolichess
max_gamesNo
depthNo
num_drillsNo
include_daily_puzzleNo

TDQS

A3.7/5.0
Behavior4/5

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

Without annotations, the description carries the full burden. It discloses that it runs diagnose_weaknesses internally, returns drill positions with specific details (FEN, side, engine move), and orders by weaknesses. It doesn't mention read-only nature or potential side effects, but the behavior is mostly 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?

The description is two sentences long, very concise with no fluff. The first sentence captures the core purpose, and the second details the behavior. It is well-structured and efficient.

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

Completeness2/5

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

Given the tool has 6 parameters, no output schema, and no annotations, the description lacks essential context. It does not explain parameter meanings, error conditions, prerequisites, or the output format beyond a brief mention. This leaves an agent underinformed for proper invocation.

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

Parameters1/5

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

Schema description coverage is 0%, and the description provides no explanations for any of the 6 parameters. The titles and defaults are insufficient for an agent to understand the meaning and constraints of parameters like source, max_games, depth, or num_drills.

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 that it builds a personalised drill set from the player's own mistakes, distinguishing it from sibling tools like diagnose_weaknesses which only analyze weaknesses. It specifies the source (blunders) and output format (FEN, side to move, engine move).

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 implies when to use (to generate drills from mistakes) but does not explicitly state when not to use or provide alternative tool comparisons. The mention of 'optional Lichess daily puzzle' gives some context, but lacks explicit usage guidelines.

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.

  1. 6 tool updatesv0.1.0
    • First observedanalyze_game
    • First observedanalyze_position
    • First observeddiagnose_weaknesses
    • First observedengine_status
    • First observedfetch_recent_games
    • First observedrecommend_drills

TDQS

A4.2/5.0

Scored across 6 tools

Disambiguation5/5

Each tool targets a distinct function: game analysis, position evaluation, weakness diagnosis, engine status check, game fetching, and drill recommendation. No two tools overlap in purpose.

Naming Consistency5/5

All tools follow a consistent verb_noun pattern using snake_case (e.g., analyze_game, diagnose_weaknesses). The naming is predictable and clear.

Tool Count5/5

With 6 tools, the server is well-scoped for a chess coach. Each tool serves a clear and necessary role without redundancy or excessive complexity.

Completeness4/5

The tool set covers all core coaching workflows: analysis, diagnostics, and drill generation. A minor gap is the lack of a tool for creating or editing chess data, but this is outside the typical coach scope.

Maintenance

ActivityInactive
ResponsivenessNo issues

Related MCP Connectors

Related MCP Servers

  • A
    license
    Not graded
    quality
    D
    maintenance
    A Model Context Protocol server that lets your AI talk to Stockfish. Because apparently we needed to make chess engines even more accessible to our silicon overlords.
    15
    MIT
  • A
    license
    Not graded
    quality
    D
    maintenance
    A powerful chess engine and game server built with the Model Context Protocol (MCP). Play chess against AI, analyze positions, and integrate chess functionality into your AI applications.
    15 npm
    1
    ISC
  • F
    license
    Not graded
    quality
    C
    maintenance
    An MCP server that exposes Stockfish chess analysis to LLM chat clients, enabling move analysis, game review, and explanation of engine choices.
    -