casecraft
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., "@casecraft run me through a case"
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.
casecraft
Spoken consulting case interview practice, run by Claude.
Open any Claude session and say "run me through a case." A browser tab opens, Claude reads you a case out loud, you answer out loud, and you get graded the way a real interviewer grades — on structure, analytics, judgment and communication, not just whether the number was right.
You never see the question. That's the point. Reading a case off a screen isn't a case interview.
./install.shThen, in Claude: "run me through a case" · "drill me on hard math" · "what am I bad at?"

How it works
Claude ──MCP──► casecraft ──SSE──► browser tab ──► 🔊 reads the case
│ └───► 🎤 hears your answer
├── case library (prompts, rubrics, answer keys)
├── deterministic grading (math, delivery)
└── progress log → weakness-targeted drillsClaude is the interviewer. It never receives the case text, the rubric, or the answer key before you've answered — those live in a separate process, so there's nothing to leak. Case prompts travel to your speakers and are never returned through MCP, which is what keeps them off your screen.
Speech uses your browser's built-in Web Speech API: no model downloads, no API keys, no per-session cost. Playback rate is a true multiplier, so the three pace settings are exact.
Related MCP server: @maheidem/linkedin-mcp
What gets graded
Four dimensions, the same four every firm's feedback form uses under different
names. 3 is the bar; one 2 sinks a candidate with three 4s, which is why the
scorecard reports a limiting_factor rather than an average.
Structure | MECE buckets stated upfront, hypothesis-led, prioritized |
Analytics | Accurate, sanity-checked, reasoned out loud |
Judgment | Says "so what", prioritizes, brings business sense |
Communication | Top-down, signposted, concise, conviction |
Two things happen without any model call, instantly:
Math is graded deterministically — and diagnosed, not just marked. Say "2.89 billion" on a capacity question and you get "You used all 150 seats — forgot the 80% load factor", because the case data names the mistakes candidates actually make. Intermediate steps earn partial credit, so a wrong final answer still shows where you diverged.
Delivery is analysed from the transcript — hedging, signposting, whether you led with the answer, whether you gave a number without its implication, pace against the time target. This is the feedback candidates never get, because a human coach can't count your hedges while also running the case.
Note: Whisper and the Web Speech API both clean up disfluencies, so "um" and "uh" largely don't survive transcription. Filler counts are reported as a floor. Hedging ("I think maybe") is real words and survives intact — which is why the scoring leans on it instead.
Practice modes
Full case — prompt, clarifying questions, structure, math, exhibit, synthesis, scorecard. Interviewer-led (McKinsey style) or candidate-led (Bain/BCG style).
Drills — loose questions pulled across cases. "Only hard math" is a filter, because questions are first-class rather than buried inside case documents. Selection biases toward what you keep getting wrong, without ever fully excluding the rest.
Your own cases
casecraft ships with original cases only. Casebooks are copyrighted, so the
engine ships empty of them by design — import your own and they load
automatically alongside the bundled ones, from ~/.casecraft/cases/.
python -m casecraft.ingest yourcasebook.pdf # --dry-run to previewHandles Darden-format casebooks and math drill playbooks, including PDFs whose
fonts extract as gibberish. Imported cases never land in data/cases/,
so nothing you distribute can contain them.
Two honest caveats about auto-imported content:
Math is graded against the worked solution, not a number. Pulling a final answer out of free-form worked solutions proved about one-in-three reliable — multi-part questions and intermediate results all look like conclusions to a parser. Rather than mark correct answers wrong, imported math uses an
openrubric and keeps the heuristic number in_candidate_expected. Verify it and swap in{"kind": "numeric", "expected": ...}to get instant deterministic grading for that question.Questions are dropped rather than guessed. These slides interleave the question with its answer, so anything that doesn't read as a question is skipped — you get fewer questions, but none that read the solution aloud.
The format is documented in SCHEMA.md. The one thing worth getting
right when you parse: answer keys have to become rubrics, not prose. Prose
can't be scored, can't drive a targeted probe, and can't tell you which skill
you're weak at. Pay particular attention to common_errors — it's the field a
naive parser skips and the one that turns "incorrect" into a diagnosis.
Layout
casecraft/
server.py MCP tools — the interviewer's hands
room.py local HTTP + SSE bridge to the browser
session.py interview state machine
library.py case loading, drill queries, weakness-biased sampling
scoring.py numeric grading + bucket policy + scorecard
delivery.py hedging, signposting, pacing, "so what"
progress.py attempt log → weakness model
static/ the interview room
skill/casecraft/SKILL.md how Claude should interview
data/cases/ bundled original casesDevelopment
.venv/bin/python -m casecraft --check # the JSON loads
.venv/bin/python -m pytest tests/ -q # 130 unit + integration tests
.venv/bin/python -m tests.soak # every case + drills + API abuse
.venv/bin/python -m tests.playthrough # one full interview, adversarially
.venv/bin/python -m tests.stress # concurrency, state leaks, ports
.venv/bin/python -m tests.fuzz 7 # 180 random tool calls, invariants
.venv/bin/python -m tests.calibrate # tiered answers: better never scores worse
.venv/bin/python -m tests.validate_cases # case coherence: refs, weights, collisions
.venv/bin/python -m tests.dogfood # 3 full flows, dialogue printed for reading
.venv/bin/python -m tests.inspect_output # scorecards/reports as a candidate reads themTests deliberately weight the failure paths. A prep tool that only works on model answers is useless — the product is what it says when you're wrong.
The suites are layered on purpose, because each caught bugs the others could not see:
pytest pins grading policy, delivery analysis, and source-level invariants — every tool that speaks must reopen the microphone; the page may never invent turn state locally.
soak drives all 25 cases and both drill modes to a scorecard. Most of the library is imported from PDFs where fields are missing and rubrics are
openrather thanbuckets; bugs there are invisible on the two hand-written cases.playthrough runs one interview while abusing it: talking out of turn, empty answers, 20,000-character replies, unicode, prompt injection.
stress hits concurrency and lifecycle. It found a captured answer surviving into the next case, where it would have been graded against a different rubric with a plausible-looking verdict.
Diagnosing a live room
The room is introspectable, so an agent never needs a human to describe what they see on screen:
curl -s localhost:7654/debugpage_problem is the field to read first: it names why the room won't work
(no tab open, stale build, audio still locked by the browser) or is null when
healthy. POST /debug/act drives the room as the candidate — press_start,
say, open_mic — so a whole interview can be rehearsed with nobody present.
Requirements
Python 3.11+
Chrome or Safari (Firefox has no speech recognition — you can still type)
macOS or Linux
Browser speech recognition sends audio to the browser vendor's service. If you'd
rather keep it on-device, pip install -e ".[local-stt]" and the room will use
local Whisper instead.
Available Tools
19 toolsanswer_clarificationA
Release one withheld fact, if the candidate asked for it.
This is the only way case data reaches them, and it's deliberate: good
candidates ask, weak ones assume. If nothing matches, you get matched: false — say you don't have that information and let them proceed. Don't
invent facts; you genuinely don't have the case.
Inputs: question (required). Returns: object
ask_case_promptA
Read the case prompt aloud to open the interview.
Returns no content — the prompt reaches the candidate inside the room only, never through this tool result (which would land in the chat transcript). After this, expect clarifying questions before they start structuring.
Inputs: no named parameters. Returns: object
catalogA
List every case and drill category available, with counts.
Safe to show the candidate — it contains titles and counts, never content. Use it to offer choices ("I have a profitability case in airlines and a market-entry case in consumer health — which would you like?").
Inputs: no named parameters. Returns: object
collect_answerA
Listen for the candidate's spoken answer, then grade what can be graded.
Call it right after asking a question. If it returns ready: false, they're
still thinking — call it again. Don't fill the silence; interviewers let
candidates work.
Math answers come back fully graded (deterministic, instant). Framework and
synthesis answers come back with the rubric's component labels and the
committed transcript — read them, decide which components the candidate
actually covered, and pass those ids to score.
Inputs: max_wait, acknowledge. Returns: object
finishA
End the session and return the scorecard.
Four dimensions, rated 1–5, where 3 is the bar. Note limiting_factor —
real interviewers decide on the weakest box, not the average, so that's what
the candidate should work on. recurring_habits are patterns seen more than
once; those matter more than any single answer.
Inputs: no named parameters. Returns: object
listenA
Hear whatever the candidate says next — not tied to any question.
This is the conversational channel: clarifying questions, "can you repeat
that", "I'm ready", thinking out loud. If it returns heard: false they're
still talking or thinking — just call it again. Never fill the silence.
Inputs: max_wait. Returns: object
next_questionA
Advance to the next question and read it aloud.
Returns metadata only — type, difficulty, time target — never the text.
Use the type to calibrate: a structure question deserves "take a minute
if you'd like"; a math question deserves silence while they work.
Inputs: read_aloud, question_id. Returns: object
probeA
Get the next hint for the current question, escalating weakest-first.
Real interviewers nudge before they explain. Speak the probe with say,
then collect_answer again. When probes run out, you've done what an
interviewer would — give the answer and move on.
Inputs: no named parameters. Returns: object
progressA
The candidate's history: weakest areas, repeated mistakes, recent attempts.
Use it to recommend what to practise, and to open a session with something
specific ("last time you dropped the load factor twice — let's do capacity
math"). detail includes per-attempt rows.
Inputs: detail. Returns: object
release_clarificationA
Release a specific withheld fact by id, when keyword matching missed it.
Use only when the candidate's question clearly maps to that topic. You are matching intent, not deciding generosity — if they didn't ask for it, don't release it.
Inputs: topic_id (required). Returns: object
repeat_questionA
Deliver the current question again. Candidates are allowed to ask.
Inputs: no named parameters. Returns: object
reveal_model_answerA
The casebook's own answer for the current question.
Only after grading. Use it to explain what a strong answer sounds like — paraphrase it conversationally rather than reading it out verbatim.
Inputs: no named parameters. Returns: object
room_actA
Drive the room as if you were the candidate. For testing, not for cheating.
This lets you rehearse or diagnose the whole flow with nobody at the keyboard — press Start, submit an answer, confirm the loop advances. During a real interview, don't answer on the candidate's behalf.
Inputs: action (required), text. Returns: object
room_statusA
Inspect the interview room: state, page health, and a timestamped log.
Use this the moment anything looks wrong — silence, a stall, an answer that never arrived. It reports what was spoken, whether the page acknowledged it, whether the mic is open and whether a tab is even connected, so you can diagnose without asking the candidate what they see on screen.
page_problem is the single most useful field: it names the reason the room
won't work (no tab, stale build, audio still locked) or is null when healthy.
Inputs: events. Returns: object
sayA
Speak in your own voice — greetings, probes, transitions, feedback.
Keep it conversational and brief — in voice mode it is read aloud, and in text mode it appears as a chat line. Either way: no lists, no markdown, no long sentences.
With expect_reply (the default) the microphone opens as soon as you stop
talking, so the candidate can just answer. Follow with listen.
Inputs: text (required), expect_reply. Returns: object
scoreA
Record which rubric components the answer covered, and get the verdict.
You supply the semantic matching; the pass/probe policy lives server-side so
it's identical for everyone. A PARTIAL verdict with a named gap is your cue
to probe rather than move on.
Inputs: covered (required). Returns: object
show_exhibitA
Display a chart or table in the room.
Exhibits are the one thing the candidate is meant to see — a real interviewer slides paper across the table. Speak the intro line, then give them a moment before asking what they make of it.
Inputs: exhibit_id. Returns: object
start_caseA
Begin a full case interview. Opens the interview room in the browser.
Returns a briefing: format, industry, difficulty, how many questions, and the topics of clarifying information available — never the facts themselves. Tell the candidate the room is open and confirm they can hear you before starting.
Inputs: speed, case_id, case_type. Returns: object
start_drillA
Begin a drill: loose questions pulled across cases, no full-case context.
This is the "only hard math" mode. Each question carries its own standalone
framing so it makes sense out of case order. With target_weaknesses, the
sampler leans toward what they keep getting wrong without excluding the rest.
Inputs: tags, count, speed, types, +3 more. Returns: object
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 19 tools
Several tools overlap in purpose: listen and collect_answer both capture speech; answer_clarification and release_clarification both release withheld facts. However, descriptions help distinguish general conversation from graded answers and keyword vs id-based release, so most tools remain distinct.
Tool names mix verb_noun patterns (start_case, collect_answer) with noun phrases (catalog, progress, room_status) and single verbs (listen, say). While all use snake_case and are readable, the lack of a consistent verb-first convention creates a mixed style.
19 tools is slightly above the typical well-scoped range, but given the full lifecycle of case interview practice—session control, questioning, grading, feedback, room management—each tool serves a clear purpose and the count is justified.
The tool set covers the entire interview flow: starting cases and drills, delivering questions, collecting and grading answers, providing hints and model answers, managing clarifications, displaying exhibits, monitoring room health, and finishing with a scorecard. No critical gaps or dead ends exist.
Related MCP Connectors
Record your pitch in Claude or ChatGPT and get instant feedback on your delivery.
AI interview practice and career preparation with user-controlled guidance.
Chief of Staff, strategy and writing tools that give your Claude subscription structure and memory.
Mock job interviews: prepare a spoken practice interview for any role, get a link. No sign-in.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceEnables Claude to intelligently query and analyze your resume using RAG technology. Supports skill matching against job requirements and answering questions about your professional background from locally stored resume files.MIT
- AlicenseBqualityDmaintenanceIntegrates with Claude to enable LinkedIn post creation, profile optimization, content generation, and analytics through natural language.1357 npm2MIT
- AlicenseBqualityCmaintenanceA session-based thinking workspace for Claude that preserves and structures reasoning text. Supports structured session names, search, and persistent storage for complex problem-solving.109 npm2MIT
- AlicenseAqualityDmaintenanceEnables interview preparation by analyzing resumes and job descriptions, generating role-specific questions, and evaluating answers using MCP tools integrated with an OpenAI agent.5MIT