Skip to main content
Glama
Coffee Shop MCP

Coffee Shop MCP

☕ Coffee Shop MCP

A hands-on Model Context Protocol (MCP) project. An LLM (VS Code Copilot in Agent mode) takes your coffee order and "makes" it by coordinating a Barista server and four machine servers.

Built with the official MCP Python SDK's FastMCP.


How it works

The LLM is the orchestrator. Servers are dumb specialists — none of them talk to each other. The Barista returns a recipe, and the LLM walks that recipe across the machines.

flowchart TD
    User([You]) --> LLM[VS Code Copilot<br/>orchestrator]
    LLM --> Barista[Barista server<br/>menu · orders · recipes]
    LLM --> Grinder[Grinder]
    LLM --> Brew[Brew unit]
    LLM --> Steamer[Steamer]
    LLM --> Dispenser[Dispenser]

Related MCP server: mcp-coffee

Order flow

sequenceDiagram
    participant U as You
    participant L as Copilot (LLM)
    participant B as Barista
    participant M as Machines

    U->>L: What's on the menu?
    L->>B: get_menu()
    B-->>L: 4 drinks
    U->>L: Large latte, extra shot
    L->>B: place_order(...)
    B-->>L: order id + recipe
    L->>M: grind → brew → steam → dispense
    L->>B: mark_order_ready()
    L-->>U: Your latte is ready ☕

Menu

Drink

Milk?

Notes

Espresso

No

Base shot

Americano

No

Espresso + hot water

Latte

Yes

Steamed milk, light foam

Cappuccino

Yes

Steamed milk, thick foam

Machines

Component

Job

Used by

Grinder

Beans → grounds

All

Brew unit

Pull the shot (+ Americano water)

All

Steamer

Texture milk

Latte, Cappuccino

Dispenser

Assemble the cup

All

Espresso skips the Steamer. Latte vs Cappuccino differ only in foam thickness.


Project layout

coffee-shop-mcp/
├── .vscode/mcp.json
└── src/coffee_shop_mcp/
    ├── server.py       # Barista
    ├── grinder.py
    ├── brew_unit.py
    ├── steamer.py
    └── dispenser.py

Setup

uv venv
uv add "mcp[cli]"

Test one server in the browser Inspector:

uv run mcp dev src/coffee_shop_mcp/server.py

Run in VS Code

.vscode/mcp.json:

{
  "servers": {
    "coffee-shop": { "type": "stdio", "command": "uv",
      "args": ["run", "python", "src/coffee_shop_mcp/server.py"] },
    "grinder":     { "type": "stdio", "command": "uv",
      "args": ["run", "python", "src/coffee_shop_mcp/grinder.py"] },
    "brew-unit":   { "type": "stdio", "command": "uv",
      "args": ["run", "python", "src/coffee_shop_mcp/brew_unit.py"] },
    "steamer":     { "type": "stdio", "command": "uv",
      "args": ["run", "python", "src/coffee_shop_mcp/steamer.py"] },
    "dispenser":   { "type": "stdio", "command": "uv",
      "args": ["run", "python", "src/coffee_shop_mcp/dispenser.py"] }
  }
}
  1. Open the folder in VS Code, click Start on each server in mcp.json.

  2. Open Copilot Chat → Agent mode.

  3. Say: "What's on the menu? Then make me a large latte and run it on the machines."


Notes

  • In-memory only — orders reset when the server restarts.

  • Simulated hardware — machines return text results, nothing physical happens.

  • Idle servers get stopped/restarted by VS Code automatically — that's normal.

A learning project. ☕

Available Tools

7 tools
check_order_statusA

Check the current status of a placed order by its order ID. Returns the drink, size, current status, the full step-by-step status history with timestamps, and when it was placed. Use this to tell the customer whether their order is still being made or is ready.

Inputs: order_id (required).

get_customization_optionsA

Get the available customization options for a specific drink (size, extra shot, etc.). Call this after the customer has chosen a drink from the menu, so you know what to ask them about. The drink argument must be a drink name from the menu.

Inputs: drink (required).

get_menuA

Get the coffee shop's current menu: every drink we can make, whether it contains milk, and a short description. Call this FIRST to see what the customer can order. Do not guess drinks or read source files.

Inputs: no named parameters. Returns: result

mark_order_readyA

Mark an order as ready for collection. Call this after ALL machine steps in the recipe have been completed successfully. Flips status to 'ready', records the completion timestamp, and closes the lifecycle. After calling this, tell the customer their order is ready to collect.

Inputs: order_id (required).

pingA

Check that the Barista MCP server is alive and responding.

Inputs: no named parameters. Returns: result

place_orderA

Place a coffee order. Call this once the customer has chosen a drink and confirmed their customizations. Returns an order ID and the recipe (the ordered list of machine steps to make the drink). drink must be on the menu; size is small/medium/large; extra_shot adds a second shot.

Inputs: drink (required), size, extra_shot.

update_order_statusA

Update the current machine step for an in-progress order. Call this as you BEGIN each step in the recipe: 'grinding', 'brewing', 'steaming' (milk drinks only), 'dispensing'. Do NOT use this for 'pending' (set by place_order) or 'ready' (set by mark_order_ready). Calling 'steaming' on a non-milk drink is a validation error.

Inputs: status (required), order_id (required).

Tool Schema Changelog

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

Loading tool schema changelog…

    TDQS

    A4.5/5.0

    Scored across 7 tools

    Disambiguation5/5

    Each tool targets a distinct aspect of the coffee ordering workflow: menu, customization, placing, status, step updates, readiness, and health check. There is no overlap or ambiguity.

    Naming Consistency5/5

    All tool names follow a consistent verb_noun pattern with underscores (e.g., get_menu, place_order). 'ping' is a standard exception for health checks and does not disrupt the pattern.

    Tool Count5/5

    With 7 tools, the set is well-scoped for a coffee shop ordering system. Each tool serves a clear need without redundancy or missing critical functionality.

    Completeness4/5

    The tool set covers the full order lifecycle: menu browsing, customization, placing, status tracking, step updates, and marking ready. Minor gaps like cancellation or order listing are absent but not essential for the core workflow.

    Maintenance

    ActivityInactive
    ResponsivenessOutdated data

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      A
      quality
      D
      maintenance
      MCP server for controlling Meticulous espresso machines via Claude and other AI clients.
      22
      105 npm
      MIT
    • F
      license
      A
      quality
      D
      maintenance
      MCP server that recommends coffee based on preferences (mood, milk, caffeine, temperature) from a static menu; includes tools for listing menu, recommending, and explaining recommendations.
      3
      -