University Course Catalog MCP Server

An MCP (Model Context Protocol) server that exposes a university course catalog as a set of tools, resources, and prompts. The intended consumer is an AI academic advisor — a language model that needs to answer questions about courses, prerequisites, and instructors without hallucinating data. The server gives that model a structured, queryable interface backed by a real database.

Architecture

graph LR
    Client["MCP Client (LLM / Inspector)"]

    subgraph Docker["Docker Container (port 8080)"]
        subgraph Server["FastMCP"]
            T["Tools\nsearch_courses\nget_prerequisites\nlookup_instructor\nget_prerequisite_graph"]
            R["Resources\ncourse_descriptions\ndepartment_directory"]
            P["Prompts\ncourse_comparison_template"]
        end
        ORM["SQLAlchemy ORM"]
        DB["SQLite\ndata/catalog.db"]
    end

    Client -- "HTTP /mcp" --> Server
    Client -- "HTTP /health" --> Server
    T --> ORM
    R --> ORM
    ORM --> DB

Related MCP server: University Course Catalog MCP Server

Tech Stack

Project Structure

.
├── README.md
├── Dockerfile
├── docker-compose.yml
├── .dockerignore
├── .env.example
├── .gitignore
├── requirements.txt
├── data/
│   ├── catalog.db          # seeded SQLite file, committed to git
│   └── seed.py
├── src/
│   ├── __init__.py
│   ├── main.py             # FastMCP instance, health route, entrypoint
│   ├── database.py         # SQLAlchemy engine/session/Base
│   ├── models.py           # Department, Instructor, Course, Prerequisite ORM models
│   ├── schemas.py          # Pydantic input/output models for all 4 tools
│   ├── tools.py            # tool implementations
│   ├── resources.py        # course_descriptions / department_directory
│   └── prompts.py          # course_comparison_template
└── scripts/
    └── verify_server.py    # repeatable smoke-test script

Setup & Run

Docker (recommended)

docker compose up --build

The server starts on port 8080. The MCP endpoint is at http://localhost:8080/mcp, health check at http://localhost:8080/health.

Local dev

python3 -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt

# Seed the database (idempotent — safe to run multiple times)
python data/seed.py

# Start the server
python src/main.py

The server reads DATABASE_URL from the environment. Copy .env.example to .env if you want to override the default (sqlite:///./data/catalog.db).

Database Schema

departments

instructors

courses

prerequisites

MCP Tools

MCP Resources

Both resources are generated dynamically from the database on each read.

MCP Prompts

Template text:

Create a table comparing the following two courses: {{course_code_1}} and {{course_code_2}}. Include columns for Title, Credits, Description, and Prerequisites.

Example Queries

These are the kinds of natural-language questions a connected LLM could answer using the tools above:

1. "What courses do I need to take before I can enroll in Artificial Intelligence (CS401)?"

2. "Show me all the courses offered by the Mathematics department."

3. "How do I contact Dr. Sarah Chen, and what department is she in?"

4. "I want to take Database Systems — what's the full chain of prerequisites I need to complete first?"

5. "Compare Introduction to Programming and Calculus I — what are the differences in credits and content?"

Design Note: FastMCP over FastAPI

The server uses FastMCP from the MCP Python SDK directly, running with transport="streamable-http". I did not mount the MCP app inside a separate FastAPI application. Doing so (via FastAPI's .mount() applied to mcp.streamable_http_app()) is a known routing bug in the SDK where the MCP endpoint stops responding correctly after mounting. Using FastMCP.run() with its built-in Uvicorn runner avoids the issue entirely — the health endpoint is added with @mcp.custom_route("/health"), which registers it on the same Starlette app that FastMCP manages internally. One port, one process, no wrapper.

Verification

Run the smoke-test script against a locally running server:

python src/main.py &
python scripts/verify_server.py

The script uses the MCP Python client library directly (no shelling out to the inspector) and prints real JSON results for all tools, both resources, and the prompt template.