StudyBuddy
This server does not currently have a deployable release on Glama. Follow the repository's setup instructions to install and configure it for your MCP client, including any required credentials and local dependencies.
MCP in 45 Minutes — A Classroom Walkthrough
You've already given the theory. This is the "now let's see it" session. Two files, ~90 lines of Python total, nothing exotic.
Setup (5 min, do this before class starts)
pip install "mcp[cli]==1.29.0"That's the only dependency. Both files run with plain python3.
Related MCP server: Demo MCP Server
The three files
File | Role | What it plays the part of |
| MCP server | The "tool box" — e.g. a school's database, a weather API, a calculator |
| MCP client (scripted) | The "app" that wants to use those tools — calls are hardcoded so you can read the protocol steps in order |
| MCP client (REPL) | Same idea, but it asks you which tool to call and for its arguments, live in the terminal |
About interactive_client.py
Run it with:
python3 interactive_client.pyIt connects to the server, calls list_tools(), and prints whatever tools
come back as a numbered menu — nothing is hardcoded, so if a student adds a
new tool to study_buddy_server.py, it just shows up next time this runs.
Pick a number, and for each argument the tool needs it prompts you for a
value (reading the schema FastMCP built from the function's type hints —
this is a nice moment to point out that the schema is not hand-written).
Type q to quit.
This is the best one to leave running on a projector: it's the closest
students will get to "talking to the server" without wiring up a real LLM,
and it makes the discovery step (menu built live from list_tools())
visually obvious in a way the scripted client doesn't.
Suggested flow in class
1. Read the server first, run nothing yet (10 min)
Open study_buddy_server.py on the projector. Walk through it top to bottom:
mcp = FastMCP("StudyBuddy")— creating the server and naming it.@mcp.tool()— point out this is the entire difference between "a Python function" and "a function an AI can discover and call." Nothing else changes.The docstring under each function (
"""Roll a dice...""") is not just a comment — the client/model reads this text to decide when to use the tool. This is worth emphasizing: MCP tool descriptions are part of the protocol, not decoration.mcp.run()at the bottom — starts the server listening for a connection.
Ask students: "If I wanted to add a tool that looks up tomorrow's weather, what three things would I need to write?" (a function, a docstring, the decorator) — this checks they got the pattern.
2. Run the server alone (2 min)
python3 study_buddy_server.pyIt will appear to hang / do nothing. That's the point — a server on its own is inert. It's just sitting there waiting for something to talk to it over stdin/stdout. Ctrl+C to stop.
3. Read and run the client (15 min)
Open simple_client.py. This is the file that shows the protocol steps
explicitly, because normally an AI app hides them from you:
Launch —
stdio_client(server_params)starts the server as a subprocess and opens a pipe to it.Handshake —
session.initialize(). Client and server introduce themselves and agree on what they support.Discover —
session.list_tools(). The client asks "what can you do?" and gets back the tool names + docstrings + expected inputs.Call —
session.call_tool("roll_dice", {"sides": 20}). The client asks the server to actually run one specific tool with specific arguments, and gets a result back.
Run it:
python3 simple_client.pyPoint out: no AI model was involved anywhere in this script. We (the humans) hardcoded which tool to call. That's deliberate — it isolates "what MCP does" from "what an LLM adds on top," which is normally where the confusion is. The LLM's job in a real app is just step 4: deciding which tool to call and what arguments to pass, based on the tool descriptions from step 3 and the user's message.
4. Live-code a new tool together (10 min)
Add a fourth tool to study_buddy_server.py as a class, e.g.:
@mcp.tool()
def word_of_the_day() -> str:
"""Return a random vocabulary word with its definition."""
words = {
"ephemeral": "lasting for a very short time",
"resilient": "able to recover quickly from difficulty",
"lucid": "clear and easy to understand",
}
word, definition = random.choice(list(words.items()))
return f"{word}: {definition}"Then add one line to simple_client.py to call it, and re-run. This is the
moment that usually makes it click: adding a capability took one decorator
and zero protocol code.
5. Bonus, if time allows: connect it to Claude Desktop
If any students have Claude Desktop installed, show them that the same
study_buddy_server.py file can be registered in Claude Desktop's config
(claude_desktop_config.json) instead of simple_client.py, and then Claude
itself — not a hardcoded script — decides when to roll a dice or quiz them,
based on what they type in chat. This is the "aha": the server code never
changes, only who's driving the client side.
Key takeaway to write on the board
MCP doesn't make the AI smarter. It gives the AI a standard way to discover and call tools it doesn't know about in advance — so anyone can plug new capabilities into any AI app without custom integration code.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
This server cannot be deployed
Maintenance
Related MCP Connectors
Educational MCP server with 17 math/stats tools, visualizations, and persistent workspace
Related MCP Servers
- FlicenseNot gradedqualityDmaintenanceA basic educational MCP server that provides simple tools for mathematical calculations, text manipulation, and time retrieval. Designed for learning MCP implementation patterns and development purposes.-
- FlicenseBqualityDmaintenanceA simple demonstration MCP server that provides basic utility tools including dice rolling and number addition functionality. This server serves as a tutorial example for setting up both local and remote MCP servers using FastMCP.3-
- FlicenseNot gradedqualityDmaintenanceA simple educational MCP server providing basic math operations, string manipulation, and greeting functionality. Demonstrates how to implement MCP tools for learning purposes.-
- FlicenseAqualityDmaintenanceAn educational MCP server demonstrating tools, resources, and prompts for learning the Model Context Protocol.255 npm-