Skip to main content
Glama

English

Lichess MCP Analyzer

MCP server pro analýzu šachových partií, detekci vzorových chyb (pattern library jako kompresní model dle T. Mikolova) a spaced repetition trénink (SM-2-like; FSRS zatím neimplementován).

Nová session: začni v docs/SESSION_HANDOFF_2026-11-17.md (current stav, příkazy, otevřené položky).

Verze: 0.1.0 | Stav (2026-11-18): single-game pipeline [2.15] (compact 2.9 default, detailed 1.2) | Testy: 556 fast (bez test_engine_client.py) / 18 real-engine (pinnutý Stockfish 18) | Nástrojů: 18 | Schémata: compact 2.9 / detailed 1.2 / cross-game 1.4 / game_full 1.0

Proč?

Tento repozitář vzniká se dvojím účelem:

  1. Šachový analyzátor — personalizovaný tréninkový nástroj, který stáhne tvoje partie z Lichess, analyzuje každý tah Stockfishem, detekuje 17 vzorových patternů (A–S + U/V) z herní historie, diagnostikuje fázové slabiny a pomáhá se z nich učit pomocí spaced repetition.

  2. MCP stavebnice — demonstrační projekt, na kterém se ověřují principy tvorby MCP serverů v praxi. Každá komponenta (Lichess API, Stockfish engine, pattern detection engine, SRS, B2B-Knowledge-Base persistence) je samostatně použitelná a přenositelná do jiné domény.

"Build tools for yourself first. If they solve a real problem, they solve a general one."

Related MCP server: chess-coach-mcp

Jak to funguje?

Tvoje otázka (v opencode)
       |
       v JSON-RPC 2.0 (stdio)
       |
lichess-analyzer-mcp (Python FastMCP)
       |
       +--- Lichess API (berserk) --------- lichess.org
       +--- Stockfish 18 (UCI) ------------ lokální binary
       +--- Pattern detector -------------- kompresní model (Mikolov)
       +--- BlunderFactSheet -------------- DBCL Phase 2 (context window, engine_lines, pattern_matches)
       +--- Narrative validator ----------- LLM hallucination guard (5 claim categories)
       +--- LLM reasoning (cascade) ------- NVIDIA / Cerebras / DeepSeek V4 Flash
       +--- SM-2-like engine -------------- spaced repetition
       +--- KB writer --------------------- B2B-Knowledge-Base
       +--- MD reporter ------------------- data/reports/ (gitignored)

Pattern detection jako kompresní model

"Reprezentace reality minimalizující komplexitu, predikční chybu a výpočetní náklady."

Lossy Compression Principle (T. Mikolov / CPM)

Pattern detection = lossy compression. Cílem je najít vzory, které popíšou realitu s maximální entropickou hodnotou na minimum tokenů. Šachový pattern artifact je kompresní model hráče: minimalizuje komplexitu (14 patternů místo 1000+ tahů), predikční chybu (Stockfish cp_loss jako ground truth) a výpočetní náklady (2s cached runtime).

Validace (MSE)

  • MSE zprava: predikce tahů na základě patternů vs realita (Stockfish hodnocení)

  • Pokud MSE(pattern) < MSE(průměr), model je validní

  • Pokud MSE(pattern) ≈ MSE(průměr), pattern je noise

Ztrátová komprese

Pattern library ignoruje jednotlivé tahy (šum) a extrahuje behaviorální vzory (signál). Ztrátová komprese = ztratit detaily (přesná hodnota cp_loss) kvůli zachycení vzoru (hráč preferuje X).

Pravidlo: Pattern je dobrý, pokud:

  • zachycuje chování (signál)

  • odstraňuje jednotlivé chyby (šum)

  • neodstraňuje strukturu (trendy, fázové slabiny)

Occamova břitva

Kompresní poměr (compression_ratio = raw_cost / pattern_cost) je měřítko Occamovy břitvy. Ze dvou patternů, které stejně dobře vysvětlují data, je ten s vyšším kompresním poměrem správnější.

Confidence vzorec (Mikolov)

final_confidence = 0.5 × compression_score + 0.3 × entropy_score + 0.2 × sample_score

Řeší small-N authority problem: pattern je validní i při N < 25, pokud dobře komprimuje (compression_ratio > 1.5 = signal, > 10 = silný signal, < 1.0 = noise).

Sémantická integrita — lekce z pattern O

CR = N / (C_impl + C_udrz) dává smysl POUZE pokud N = počet instancí téže věci.

Pattern O byl původně pojmenován "Repetition avoidance greed", ale kód detekoval flat eval plateau → blunder, nikoliv repetition refusal. Výsledek: CR=47.8 měřilo noise, ne signal. Oprava: rename na "Stagnační panika" (Option A) — popis nyní odpovídá kódu. Viz docs/01_EVIDENCE_DIGEST.md §4 (historický záznam).

Pravidlo: Každý pattern musí projít sémantickým auditem (AUD fáze): shoduje se jméno, mechanismus, hypotéza s kódem? Pokud ne — opravit popis nebo opravit kód.

Nástroje (18 MCP toolů)

Tool

Popis

lichess_fetch_games

Stáhne recentní partie hráče z Lichess (max 999, berserk pagination fix)

lichess_games_index

Vrátí cache index her dle resultu (win/loss/draw)

lichess_analyze_game

Analyzuje jednu partii Stockfishem (depth 8-24, per-move cp_loss, BlunderFactSheet)

lichess_analyze_position

Analyzuje FEN pozici (depth 8-24, multipv 3, cloud eval optional)

lichess_opening_explorer

Prozkoumá zahájení v Lichess / Masters databázi

lichess_player_profile

Vrátí profil, ratingy a statistiky hráče

lichess_diagnose_player

Diagnostikuje slabiny přes více partii (fáze, openings, ACPL)

lichess_match_patterns

Detekuje vzorové chyby A–S + podpora game_ids pro anonymní hry

lichess_analyze_pending

Batch analýza nezpracovaných her (pending detection consistency)

lichess_analyze_anonymous_session

Dávková analýza anonymních her (URL/ID/txt, label support, agregace)

lichess_import_pgn

Importuje PGN z libovolného zdroje do analyzy

lichess_coaching_single_game

Coaching report jedné hry (contract v1.2, deterministický fallback)

lichess_coaching_cross_game

Cross-game coaching přes více partií

lichess_coaching_opening_report

Report zahájení z více partií

lichess_coaching_opponent_pool

Analýza poolu soupeřů z game_ids

lichess_coaching_training_plan

Tréninkový plán podle slabin a dostupného času

lichess_persist_report

Generuje a ukládá report na disk (docs / KB)

lichess_workspace_info

Vrátí kontext pracovního prostoru

Compact JSON 2.9

Kanonický runtime kontrakt (pole, null/omission politika, alias collisions, prompt a příklad) je v docs/COMPACT_JSON_FOR_LLM.md. Schema: schemas/single_game_v2_compact_2.9.json.

DBCL Phase 2 — Implementovaný stav

BlunderFactSheet (models/analysis.py)

Per-blunder struktura s:

  • fen_before, board_state (was_in_check, checking_pieces, capture/king check)

  • legal_moves (captures/king_moves/blocks/checks)

  • engine_lines (rank, move_san, eval_cp, win_prob, PV)

  • played_move_rank, pattern_matches (pattern_id, name, confidence, evidence)

  • context_window (3 tahy před/po s eval + win_prob)

  • detector_version: DBCL-20261117-dev

Narrative validator (services/narrative_validator.py)

5 claim categories pro LLM hallucination guard: piece-on-square, check, capture, eval-number, king-move. Každá kategorie má vlastní validační funkci.

Engine lines silent fail — root cause fixed

30% BFS mělo 0 engine_lines kvůli board.san(m) AssertionError při multi-move PV. Fix: sequential board.copy() + try/except. RUN_005: 0% failure (ze 70/70 BFS). Viz docs/01_EVIDENCE_DIGEST.md §3.

Pattern N — x-ray pin detection

Detekován v _per_blunder_patterns(): centipawn_loss ≥ 200 + phase=endgame + was_in_check. Testy v tests/test_dbcl.py.

Pattern I → concept

Pattern I (Bait trap) přesunut na manual_only, auto-detekční kód sloučen do I2 (Gift exploitation). AUD-03/11 RESOLVED.

LLM Reasoning Pipeline

Deterministický výstup (patterny + weakness report) je transformován do přirozeného tréninkového reportu pomocí kaskády LLM providerů.

Architektura

Pipeline data (patterns + weakness)
       |
       v build_coaching_prompt()
       |
       v LLM cascade (první úspěšný vyhrává)
       |
       +--- NVIDIA (free) ............ nemotron-3-super-120b
       +--- Cerebras (free) .......... gpt-oss-120b
       +--- DeepSeek V4 Flash ($) .... deepseek-v4-flash ($0.14/$0.28 per 1M tok)
       |
       v generate_md_report()
       |
       v data/reports/coaching_report_{user}_{ts}.md (gitignored)

Přepíná se env var DEFAULT_PROVIDER:

  • "" (nezadáno) → NVIDIA → Cerebras → DS V4 Flash

  • cerebras → Cerebras → NVIDIA → DS V4 Flash

  • deepseek → DeepSeek V4 Flash → NVIDIA → Cerebras

Pipeline mode

run_coaching_pipeline(mode="auto") volí architekturu dle golden rules:

Mode

Kdy

Co dělá

auto

default

N≤30 → monolit, N>30 → inkrementální

mono

rychlá analýza

1 LLM call, raw data v promptu

incremental

stovky her, PGN import

per-game LLM cache + agregace se sumárii

Porovnání providerů (5 her, stejná data)

Provider

Model

Tokens

Latence

Cena/5her

SNR

NVIDIA

nemotron-3-super-120b-a12b

2 597

17s

$0.000

57%

Cerebras

gpt-oss-120b

2 677

-

$0.000

54%

DeepSeek V4 Flash

deepseek-v4-flash

3 876

31s

$0.001

93%

SNR = sémantická věrnost vůči vstupním datům (konfidence %, phase ACPL, žádné inventované patterny).

API klíče (volitelné)

Do .env (všechny jsou free kromě DeepSeek):

NVIDIA_API_KEY=nvapi-...
CEREBRAS_API_KEY=csk-...
DEEPSEEK_API_KEY=sk-...       # společný pro DS Chat i V4 Flash
LLM_MAX_TOKENS=4000            # default 2000, pro plný report 4000

Rychlý start

1. Stáhnout repo

git clone https://github.com/outpost2026/lichess-mcp-analyzer.git
cd lichess-mcp-analyzer

2. Stáhnout Stockfish

powershell -File scripts\setup_stockfish.ps1

Nebo stáhni ručně z official-stockfish/Stockfish a vlož stockfish.exe do stockfish/ adresáře.

3. Nastavit LICHESS_TOKEN

Vytvoř .env soubor v repo root:

LICHESS_TOKEN=lip_xxx

Token vytvoříš na lichess.org/settings/oauth.

4. Spustit MCP server

uv sync
uv run python -m lichess_analyzer_mcp.server

Server se připojí přes stdio. Pro opencode ho registruj v opencode.jsonc:

"lichess-analyzer": {
    "type": "local",
    "command": ["cesta\\k\\repo\\.venv\\Scripts\\python.exe", "-X", "utf8", "-m", "lichess_analyzer_mcp.server"],
    "enabled": true,
    "timeout": 60000
}

5. Nebo použít CLI pipeline

# Jedna hra -> compact JSON 2.9 (výchozí, offline)
uv run python scripts\coach.py --game-id FVhqtv1S --username systeq --no-llm --out data\reports\FVhqtv1S.json

# Explicitně schema 1.2, nebo oba tvary
uv run python scripts\coach.py --game-id lxO3gwd3 --format detailed
uv run python scripts\coach.py --game-id lxO3gwd3 --format both --out both.json

# Posledních N her hráče (compact array / NDJSON)
uv run python scripts\coach.py --username systeq --batch 3 --no-llm --out data\runs\batch.json

# Batch pipeline přes celý profil (starší, cross-game)
uv run python scripts\run_pipeline.py outpost2026 --games 20 --depth 12

Ukázka použití

"Co je za hráče?"

> lichess_player_profile("outpost2026")

{
  "username": "outpost2026",
  "ratings": {
    "blitz": {"rating": 1950, "games": 342},
    "rapid": {"rating": 1880, "games": 156}
  },
  "total_games": 523
}

"Analýza poslední partie"

> lichess_analyze_game("abc12345")

{
  "game": {"opening": "Sicilian Defense", "result": "1-0"},
  "stats": {"total_acpl": 45.2, "blunders": 1, "total_moves": 42},
  "blunders": ["Move 28: Nxe5 (loss 450cp)"]
}

"Diagnóza slabin"

> lichess_diagnose_player("outpost2026", max_games=15)

{
  "total_acpl": 62.3,
  "phase_weaknesses": {
    "middlegame": {"acpl": 78.1, "blunders": 4},
    "endgame": {"acpl": 45.0, "blunders": 1}
  },
  "top_weaknesses": [
    "Tactical awareness in middlegame transitions",
    "Opening preparation: Sicilian Defense"
  ]
}

"Najdi vzorové chyby"

> lichess_match_patterns("outpost2026")

{
  "patterns_detected": [
    {
      "pattern_id": "B",
      "pattern_name": "Automatic grab",
      "confidence": 85,
      "severity": "high",
      "mitigation": "3-sec pause + 'A CO ON?' before every capture"
    }
  ]
}

Struktura repozitáře

lichess-analyzer-mcp/
├── stockfish/               ← Stockfish 18 binary (necommitováno)
├── src/
│   └── lichess_analyzer_mcp/
│       ├── app.py               ← FastMCP instance
│       ├── server.py            ← Entry point + .env load + tool registrace
│       ├── models/              ← Datové modely (dataclasses)
│       │   ├── game.py          ← GameSummary, MoveAnalysis, GameAnalysis
│       │   ├── analysis.py      ← BlunderFactSheet, PositionAnalysis, WeaknessReport
│       │   ├── pattern.py       ← PatternDef, PatternMatch, PatternLibrary
│       │   ├── srs_card.py      ← SRSCard, FSRSState
│       │   └── player_profile.py ← PlayerProfile, OpeningStats
│       ├── services/
│       │   ├── lichess_client.py    ← berserk wrapper (fetch, index, cache)
│       │   ├── engine_client.py     ← Stockfish UCI wrapper (depth limit, PV SAN fix)
│       │   ├── game_analyzer.py     ← per-move eval + BlunderFactSheet + per-blunder patterns
│       │   ├── pv_recovery.py       ← retry PV pro blundery/mistaky bez engine_lines (FIX-014)
│       │   ├── compact_serializer.py ← schema 2.7 (default) + validace + null politika
│       │   ├── game_llm_cache.py    ← per-game LLM cache
│       │   ├── llm_client.py        ← multi-provider LLM cascade
│       │   ├── narrative_validator.py ← LLM hallucination guard (5 claims)
│       │   ├── pattern_detector.py  ← 16 detektorů (A–S + U/V; I manual_only)
│       │   ├── diagnostician.py     ← cross-game weakness report
│       │   ├── srs_engine.py        ← SM-2 spaced repetition
│       │   ├── compressibility_validator.py ← compression ratio validation
│       │   └── pattern_artifact_validator.py ← pattern semantic contract
│       ├── tools/               ← 18 MCP toolů
│       ├── resources/           ← L2 Resources (analysis, patterns)
│       ├── kb/
│       │   ├── writer.py        ← KB persistence layer
│       │   ├── md_reporter.py   ← MD report generování
│       │   └── schemas.py       ← KB schema definitions
│       └── patterns/
├── scripts/
│   ├── coach.py                 ← Jednotný CLI: hra / PGN / batch, compact 2.9 default
│   ├── run_pipeline.py          ← CLI batch pipeline
│   ├── coach_single.py          ← Starší CLI single-game (deprecated)
│   ├── mcp_call.py              ← CLI runner pro všech 18 MCP toolů
│   ├── pgn_to_compact.py        ← Deprecated shim nad coach.py
│   ├── setup_stockfish.ps1      ← Automatické stažení Stockfish
│   └── ...                      ← 20+ pomocných scriptů
├── tests/                       ← 556 fast + 18 real-engine (2026-11-18; marker real_engine)
│   ├── test_services.py         ← modely, komprese, validace
│   ├── test_prompt_contract.py  ← schema a mapování promptů
│   ├── test_engine_client.py    ← Stockfish (sdílený engine; real-engine = marker real_engine)
│   ├── test_board_facts.py      ← P0-1: centrální predikáty S, A1 regrese, ekvivalence BFS/single-game
│   ├── test_pattern_unification.py ← P0-2: BFS = single-game patterny (B/J/R/S/C/T), shoda confidence
│   ├── test_phase_p03.py        ← P0-3: phase_method/chess_phase, oba režimy R, 14-figur test
│   ├── test_pattern_semantic_contract.py ← semantic contract + min_games
│   ├── test_dbcl.py             ← win_prob, BFS round-trip, narrative validator, N
│   ├── test_depth_policy.py     ← depth a časová politika
│   ├── test_determinism.py      ← determinismus výstupů
│   ├── test_deterministic_report.py ← deterministický report, slabé/čisté fáze
│   ├── test_compact_serializer.py ← schema 2.7, null politika, eval okno, PV fallback, mate_in
│   ├── test_compact_tool.py     ← default compact, detailed, full alias, both
│   ├── test_coach_cli.py        ← jednotný CLI (argumenty, exit kódy, agregace)
│   ├── test_single_game_contract.py ← kontrakt 1.2 single-game
│   ├── test_pattern_coverage.py ← P0-7: matched/unclassified + důvody (D4)
│   ├── test_fix_batch1.py       ← CR-B100/B98/B121/B31 regresní testy
│   ├── test_fix_batch2.py       ← druhá dávka fixů
│   ├── test_mate_score.py       ← FIX-027 mate_in
│   ├── test_eval_consistency.py ← FIX-023 cp/eval invariant
│   └── test_cache_refresh.py    ← FIX-028 refresh cache a overhead
├── docs/                        ← 9 aktivních souborů (trim 2026-11-18)
│   ├── 00_DOCS_CONTRACT.md      ← Read order, autorita, pravidla
│   ├── SESSION_HANDOFF_*.md     ← Aktuální stav, příkazy, otevřené položky
│   ├── COMPACT_JSON_FOR_LLM.md  ← Runtime kontrakt 2.7 + game_full Appendix A
│   ├── CLI_USAGE.md             ← CLI + 18 MCP tool volání
│   ├── AUDIT_INTEGRATION_*.md   ← Závazná rozhodnutí D1–D40
│   ├── PATTERN_DISCOVERY_*.md   ← Závazná metodologie v1.7
│   ├── HALUCINACE_ROOT_CAUSE_ANALYSIS.md ← Anti-fabrikace
│   ├── 01_EVIDENCE_DIGEST.md    ← Historická evidence a decision provenance
│   └── 02_COACHING_EXEMPLARS.md ← Reprezentativní reporty + findings
├── _ARCHIVE/                    ← 113 historických artefaktů (git historie, ne aktivní navigace)
├── data/
│   ├── game_cache/              ← Cache analýz (JSON, Stockfish + LLM)
│   ├── pgn_cache/               ← PGN import cache
│   ├── resource_store/          ← L2 Resource persistence
│   └── runs/                    ← RUN_003–RUN_005 reporty
├── lichess-mcp.bat              ← Cross-shell launcher (Windows)
├── .env                         ← LICHESS_TOKEN (necommitovat)
├── README.md                    ← Tento soubor (CZ)
├── README_en.md                 ← Anglicka verze
├── pyproject.toml               ← Project config, dependencies
└── LICENSE                      ← MIT

Stack

Vrstva

Technologie

Runtime

Python 3.12+, uv

Framework

FastMCP (mcp>=1.0.0)

Lichess API

berserk>=0.14.0

Šachový engine

chess>=1.11.0 (python-chess) + Stockfish 18 BMI2

Spaced repetition

SM-2-like (FSRS vyžaduje samostatnou implementaci a migraci stavu)

HTTP / LLM API

httpx>=0.28.0

LLM providers

NVIDIA (nemotron-3), Cerebras (gpt-oss), DeepSeek (deepseek-v4-flash)

Dokuments

python-docx>=1.2.0

Persistence

B2B-Knowledge-Base (JSON + Markdown)

Testování

pytest 8+, pytest-cov, mypy

Lint

ruff (CI: E4/E7/E9/F; širší sada I/UP/N/S/E501 = tech debt)

Stav projektu

Aktuální kontrakty, validační vzorek, otevřené položky a pravidla pro agenta: docs/SESSION_HANDOFF_2026-11-17.md. Historie releasů: CHANGELOG.md. Root causes a datovaná měření z dřívějších iterací: docs/01_EVIDENCE_DIGEST.md. Reprezentativní coaching výstupy: docs/02_COACHING_EXEMPLARS.md.

Dokumentace

Čtecí pořadí, autorita souborů a pravidlo jednoho zdroje pravdy: docs/00_DOCS_CONTRACT.md. Veškeré historické artefakty jsou v _ARCHIVE/.

Inspirace a zdroje

Tento projekt není fork — je vlastní architekturou, ale cenná inspirace a infrastrukturní komponenty pocházejí z následujících open-source projektů.

Primární zdroje (knihovny)

Projekt

Autor

Použití

berserk

lichess-org / Matt Harrison

Lichess API Python client

python-chess

Niklas Fiekas

PGN/FEN parsing, UCI wrapper

Stockfish

The Stockfish team

Lokální šachový engine

fastmcp

Jeremiah Lowin

FastMCP framework

py-fsrs

Open Spaced Repetition

FSRS algoritmus

Sesterské MCP servery v portfoliu

Server

Toolů

Klíčový pattern

cnc-tools

20

Session state, caching, audit log

linkedin-analyzer

8

FastMCP, KB write-back, EROI scoring

mcp-jobs

5

Boolean AST match, multi-portal scraping

Stavba a debug engine integrace

Během vývoje byly identifikovány a opraveny dvě kritické chyby v engine_client.py:

  • Inverze perspektivy — cp_loss počítán z opačné strany

  • Best-move porovnání — cp_loss počítán jako delta before/after, nikoliv best/actual

Po opravě: ACPL MAE 3.9 oproti Lichess referenci (depth 18-22). Viz docs/01_EVIDENCE_DIGEST.md §4 (historický experiment).

Později opraven engine_lines silent fail: 30% → 0% failure rate (sequential board.copy + try/except). Viz docs/01_EVIDENCE_DIGEST.md §3.

License

MIT © 2026 Ondrej Sousek (outpost2026)

Available Tools

5 tools
lichess_fetch_gamesB

Stahne recent hry hrace z Lichess/Chess.com.

Args:
    username: Lichess nebo Chess.com username
    max_games: Maximalni pocet her (1-50)
    source: Platforma - 'lichess' nebo 'chesscom'

Inputs: username (required), source, max_games.

lichess_import_pgnA

Import and analyze a chess game from a PGN string.

Parses any PGN (lichess, chess.com, GM games, custom PGN) through the same
Stockfish pipeline used for online games. Returns per-move evaluation,
classification (blunder/mistake/inaccuracy/good/best), and phase detection.
Results are stored in L2 Resources for later retrieval.

Use this to:
- Analyze your own games from any platform
- Import GM games and compare against your patterns (via lichess_match_patterns)
- Analyze opponent games you have PGN for
- Build a custom game library from PGN files

Args:
    pgn: Full PGN string of the game (including headers)
    color: Your color ('white' or 'black', default 'white')
    depth: Stockfish analysis depth (8-24, default 14)
    game_id: Optional game identifier (auto-detected from PGN Site header if empty)

Inputs: pgn (required), color, depth, game_id.

lichess_match_patternsA

Detects known playing patterns (A-Q1) from the player's pattern library.

Analyzes recent games and matches them against the pattern library
imported from chess_pattern_v5.json. Returns detected patterns with
confidence scores, evidence, mitigation advice, and compression validation.

Args:
    username: Lichess username
    max_games: Number of games to analyze (5-50)
    depth: Stockfish depth (8-18)

Inputs: username (required), depth, max_games.

lichess_opening_explorerA

Looks up a position in the Lichess Opening Explorer.

Args:
    fen: FEN string of the position
    source: Database - 'lichess' (public games) or 'masters' (OTB master games)

Inputs: fen (required), source.

lichess_player_profileC

Returns a player's Lichess profile, ratings, and stats.

Args:
    username: Lichess username

Inputs: username (required).

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A3.7/5.0

    Scored across 5 tools

    Disambiguation5/5

    Each tool has a clearly distinct purpose: fetching games, importing PGN, matching patterns, opening explorer, and player profile. No overlap or ambiguity.

    Naming Consistency4/5

    All tools share the 'lichess_' prefix and use snake_case, but verbs are not uniformly applied: 'fetch_games', 'import_pgn', 'match_patterns' are verb_noun, while 'opening_explorer' and 'player_profile' are noun phrases. Minor inconsistency.

    Tool Count5/5

    Five tools is well-scoped for a chess analysis server. Each tool earns its place without being overwhelming or too sparse.

    Completeness4/5

    Covers core workflows: game retrieval, PGN import, pattern matching, opening lookup, and player stats. Missing a direct 'analyze game' tool that doesn't require separate PGN import, but the set is largely complete.

    Maintenance

    ActivityMaintained
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      C
      quality
      B
      maintenance
      An MCP server that enables natural language interaction with the Lichess chess platform, allowing users to play games, analyze positions, manage their account, and participate in tournaments through Claude.
      90
      20
      MIT
    • F
      license
      Not graded
      quality
      D
      maintenance
      An MCP server that exposes Stockfish chess analysis to LLM chat clients, enabling move analysis, game review, and explanation of engine choices.
      -
    • F
      license
      Not graded
      quality
      D
      maintenance
      An MCP server that fetches and filters chess.com game data, returning compact summaries instead of massive JSON, enabling LLMs to answer questions about player performance and head-to-head records.
      -