lichess-mcp-analyzer
A chess analysis MCP server for fetching games, evaluating positions/games with Stockfish, profiling players, diagnosing weaknesses, and detecting recurring patterns.
Fetch recent Lichess or Chess.com games for a username (up to 50, default 10).
Analyze a single game by Lichess game ID or PGN with Stockfish depth 8–24.
Analyze any FEN position with Stockfish or Lichess cloud eval.
Look up openings in Lichess public or masters databases.
Retrieve a Lichess player’s profile, ratings, and stats.
Diagnose cross-game weaknesses such as phase issues, leaky openings, and pattern frequencies.
Detect known playing patterns with confidence, evidence, mitigation advice, and compression validation.
Import and analyze PGN from any source, storing results in L2 resources.
Return workspace context including root path, Stockfish status, Python version, and tool count.
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., "@lichess-mcp-analyzer analyze my last 10 games and find my pattern errors"
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.
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:
Š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.
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 |
| Stáhne recentní partie hráče z Lichess (max 999, berserk pagination fix) |
| Vrátí cache index her dle resultu (win/loss/draw) |
| Analyzuje jednu partii Stockfishem (depth 8-24, per-move cp_loss, BlunderFactSheet) |
| Analyzuje FEN pozici (depth 8-24, multipv 3, cloud eval optional) |
| Prozkoumá zahájení v Lichess / Masters databázi |
| Vrátí profil, ratingy a statistiky hráče |
| Diagnostikuje slabiny přes více partii (fáze, openings, ACPL) |
| Detekuje vzorové chyby A–S + podpora game_ids pro anonymní hry |
| Batch analýza nezpracovaných her (pending detection consistency) |
| Dávková analýza anonymních her (URL/ID/txt, label support, agregace) |
| Importuje PGN z libovolného zdroje do analyzy |
| Coaching report jedné hry (contract v1.2, deterministický fallback) |
| Cross-game coaching přes více partií |
| Report zahájení z více partií |
| Analýza poolu soupeřů z game_ids |
| Tréninkový plán podle slabin a dostupného času |
| Generuje a ukládá report na disk (docs / KB) |
| 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 Flashcerebras→ Cerebras → NVIDIA → DS V4 Flashdeepseek→ DeepSeek V4 Flash → NVIDIA → Cerebras
Pipeline mode
run_coaching_pipeline(mode="auto") volí architekturu dle golden rules:
Mode | Kdy | Co dělá |
| default | N≤30 → monolit, N>30 → inkrementální |
| rychlá analýza | 1 LLM call, raw data v promptu |
| 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 4000Rychlý start
1. Stáhnout repo
git clone https://github.com/outpost2026/lichess-mcp-analyzer.git
cd lichess-mcp-analyzer2. Stáhnout Stockfish
powershell -File scripts\setup_stockfish.ps1Nebo 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_xxxToken vytvoříš na lichess.org/settings/oauth.
4. Spustit MCP server
uv sync
uv run python -m lichess_analyzer_mcp.serverServer 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 12Uká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 ← MITStack
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í |
lichess-org / Matt Harrison | Lichess API Python client | |
Niklas Fiekas | PGN/FEN parsing, UCI wrapper | |
The Stockfish team | Lokální šachový engine | |
Jeremiah Lowin | FastMCP framework | |
Open Spaced Repetition | FSRS algoritmus |
Sesterské MCP servery v portfoliu
Server | Toolů | Klíčový pattern |
20 | Session state, caching, audit log | |
8 | FastMCP, KB write-back, EROI scoring | |
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 toolslichess_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
Scored across 5 tools
Each tool has a clearly distinct purpose: fetching games, importing PGN, matching patterns, opening explorer, and player profile. No overlap or ambiguity.
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.
Five tools is well-scoped for a chess analysis server. Each tool earns its place without being overwhelming or too sparse.
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
Related MCP Connectors
An MCP server that gives your AI access to the source code and docs of all public github repos
Driflyte MCP server which lets AI assistants query topic-specific knowledge from web and GitHub.
Cloud-hosted MCP server for durable AI memory
Related MCP Servers
- AlicenseCqualityBmaintenanceAn 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.9020MIT
- AlicenseAqualityDmaintenanceA hybrid AI chess coach MCP server that uses Stockfish for grounded evaluation and LLM for natural-language coaching, enabling game analysis, weakness diagnosis, and personalized drills from your own games.618 PyPI5MIT
- FlicenseNot gradedqualityDmaintenanceAn MCP server that exposes Stockfish chess analysis to LLM chat clients, enabling move analysis, game review, and explanation of engine choices.-
- FlicenseNot gradedqualityDmaintenanceAn 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.-