Skip to main content
Glama

Anteater MCP

Release 1.0.0-beta.3 returns structured error codes from every tool and from the REST facade, so clients can tell a rejected API key from a rate limit or an upstream outage. See Changes for the REST response change.

An MCP server that lets Claude and ChatGPT help you pick classes at UC Irvine.

It wraps Anteater API — UCI's course catalogue, the live schedule of classes (WebSoc), historical grade distributions, enrollment history, prerequisite trees, AP credit, degree requirements and supplementary RMP ratings — and exposes them as 20 tools, 6 guided prompts and 4 reference resources, shaped around the questions students actually ask.

Zero runtime dependencies. Run the source with Node 24 LTS, or download a standalone Linux, macOS or Windows executable that already contains the same Node runtime.

"Find me a GE-2 for Fall that ends before 5pm and still has seats, ranked by how well people do."

Course        Title                Units  GPA   A%   n     SeatsOpen  Example meeting
------------  -------------------  -----  ----  ---  ----  ---------  ---------------------------
BIO SCI 17    EVO PSYCHOLOGY       4      3.80  88%  2410  2          TuTh 15:30-16:50 @ SH 134
UNI STU H30A  ANALYSIS HEALTH LIT  4      3.77  84%  864   15         TuTh 12:30-13:50 @ ALP 1600
LPS 31        INTRO INDUCT LOGIC   4      3.61  80%  2108  11         TuTh 14:00-15:20 @ EH 1200

Quickstart

git clone https://github.com/KKazuhaK/Anteater-MCP.git
cd anteater-mcp
node --version                         # Node 24 LTS
node anteater-mcp.mjs --list-tools     # confirm it runs

Then add it to your client — Claude Desktop, Claude Code, ChatGPT, or any other MCP client.

Nothing else is required. An API key is optional but recommended.


Related MCP server: chimeralang-mcp

Installing

Standalone binary

Each GitHub Release contains native archives for Linux, macOS and Windows on amd64 and arm64, plus SHA256SUMS.txt. These do not require Node.js:

# After downloading and extracting the archive for your platform:
./anteater-mcp --version
./anteater-mcp --list-tools

In an MCP client configuration, use the absolute path to anteater-mcp (or anteater-mcp.exe) as command and omit the args array. macOS archives are ad-hoc signed; public Developer ID signing and notarization are not yet configured.

Docker

The published image supports Linux amd64 and arm64. Docker Desktop on macOS and Windows runs the same Linux image:

cp .env.example .env
# Set ANTEATER_MCP_TOKEN in .env, then:
docker compose up -d
curl -fsS http://127.0.0.1:8787/health

The Compose service is non-root, read-only, capability-free and bound to loopback by default. See DEPLOY.md before placing it behind public HTTPS.

Claude Desktop

Open the config file:

OS

Path

macOS

~/Library/Application Support/Claude/claude_desktop_config.json

Windows

%APPDATA%\Claude\claude_desktop_config.json

Linux

~/.config/Claude/claude_desktop_config.json

Add an anteater entry. The path must be absolute — Claude Desktop does not run the server from your project directory:

{
  "mcpServers": {
    "anteater": {
      "command": "node",
      "args": ["/absolute/path/to/anteater-mcp/anteater-mcp.mjs"]
    }
  }
}

With an API key:

{
  "mcpServers": {
    "anteater": {
      "command": "node",
      "args": ["/absolute/path/to/anteater-mcp/anteater-mcp.mjs"],
      "env": { "ANTEATER_API_KEY": "your-secret-key" }
    }
  }
}

Restart Claude Desktop completely (quit, don't just close the window). You should see 20 anteater tools, and the 6 prompts appear as slash commands.

claude_desktop_config.example.json in this repo is the same thing, ready to copy.

Claude Code

claude mcp add anteater -- node /absolute/path/to/anteater-mcp/anteater-mcp.mjs

With a key:

claude mcp add anteater -e ANTEATER_API_KEY=your-secret-key -- node /absolute/path/to/anteater-mcp/anteater-mcp.mjs

Verify with claude mcp list.

ChatGPT

Two routes. The first needs no server.

  1. ChatGPT → Explore GPTs → Create → Configure → Create new action

  2. Paste the contents of gpt-actions-openapi.json into the Schema box

  3. Authentication — two workable choices:

    • None. Anteater API is readable anonymously. Simplest, but you share a global hourly quota with every other anonymous caller and will hit 429s.

    • API Key → Auth Type: Bearer, with your Anteater API key. ChatGPT then sends Authorization: Bearer <key> on every call and you get your own quota. ⚠️ The key is stored with the GPT, so anyone you share the GPT with uses your key. Fine for a private GPT; do not publish one with your key in it.

  4. Paste gpt-instructions.md into the Instructions box

The GPT calls anteaterapi.com directly. Twelve operations cover courses, WebSoc, grades, enrollment history and degree requirements.

The trade-off: the GPT receives raw JSON. WebSoc responses nest four levels deep (schools > departments > courses > sections), so broad queries get truncated by Actions — the supplied instructions tell it to always narrow. Prerequisite evaluation and conflict detection are not available; the model has to reason them out itself.

ChatGPT's Developer Mode connector needs a public HTTPS MCP endpoint:

node anteater-mcp.mjs --http --port 8787   # binds 127.0.0.1 only — do not add --host
# in another terminal
ngrok http 8787      # or: cloudflared tunnel --url http://localhost:8787

Add the URL under Settings → Connectors → Advanced → Developer mode. All 20 tools work, including batch course lookup, deterministic degree-progress checks, prerequisite checking and conflict detection.

ChatGPT's developer mode supports OAuth, no authentication, or mixed — there is no field for a custom header, so put the token in the URL query string:

https://<your-domain>/mcp?token=<ANTEATER_MCP_TOKEN>

This URL form is a compatibility option, not a security improvement: URLs may be saved in connector settings and reverse-proxy logs. Use a Bearer header whenever the client supports one.

Both transports ChatGPT accepts, SSE and streaming HTTP, are implemented. For a permanent deployment rather than a tunnel, follow DEPLOY.md — the setup is identical to the Claude one, only the connector UI differs.

⚠️ Without ANTEATER_MCP_TOKEN the endpoint is unauthenticated. Set it before exposing anything. See HTTP mode security.

⚠️ ChatGPT's MCP plugins are web-only. OpenAI's own documentation says developer mode is "available to Pro, Plus, Business, Enterprise, and Education accounts on the web" — the phone apps cannot reach an MCP server. For ChatGPT on a phone, use a Custom GPT whose Action points at this server's REST facade, described below.

Which ChatGPT route gets you what

Custom GPT + Actions

Developer mode + MCP

Server needed

No

Yes, public HTTPS

Auth options

None · API Key (Basic/Bearer/custom header) · OAuth

Access token / API key with a Bearer, Basic or custom header scheme · OAuth · none. Claude's connector dialog takes request headers too, so ?token= is only a fallback

Can carry your Anteater key

Yes, API Key → Bearer

Yes, server-side via ANTEATER_API_KEY

What the model gets

12 raw API operations, JSON

All 20 tools, formatted, plus 6 prompts and 4 resources

Prerequisite / conflict checking

No — the model must reason it out

Yes

Works on mobile

Yes

No — MCP plugins are web-only

On your phone

Claude's iOS and Android apps support remote MCP servers. Deploy this behind HTTPS, add it once on claude.ai in a browser, and it syncs to the apps — you cannot add a new server from the phone itself. DEPLOY.md has a complete recipe: token auth, a systemd unit, Caddy or nginx, and the connector setup.

The ChatGPT Custom GPT route also works on mobile and needs no server at all.

Codex

Codex speaks streamable HTTP and reads the token from an environment variable, so it never lands in a config file:

export ANTEATER_MCP_TOKEN=...   # in your shell profile
codex mcp add anteater --url https://your.domain/mcp --bearer-token-env-var ANTEATER_MCP_TOKEN

Or write it to ~/.codex/config.toml directly — a project-local .codex/config.toml takes precedence over the global one:

[mcp_servers.anteater]
url = "https://your.domain/mcp"
bearer_token_env_var = "ANTEATER_MCP_TOKEN"

Codex reads the variable at connect time and sends Authorization: Bearer <token>.

Any other MCP client

The server speaks standard MCP over stdio. Point your client at:

command: node
args:    ["/absolute/path/to/anteater-mcp/anteater-mcp.mjs"]

Or run it as a streamable-HTTP server at http://127.0.0.1:8787/mcp with node anteater-mcp.mjs --http.

Protocol versions 2025-06-18, 2025-03-26 and 2024-11-05 are all accepted; the server negotiates down rather than echoing whatever it is sent.


What you get

Tools (20)

Finding classes

Tool

What it answers

search_sections

The workhorse. Live sections for a term: times, instructor, room, seats, waitlist, final exam. Supports an exclusive day filter (daysOnly) and a blocked-window filter (avoidDays + avoidStart/avoidEnd) for "I work Monday afternoons"

recommend_courses

The one you want. Filter by GE, days, time window and open seats; rank by historical GPA

search_courses

What courses exist at all

get_course

One course in full: description, prerequisites, restrictions, what it unlocks

get_courses_batch

Up to 50 known courses in one compact comparison, with optional details

list_terms

Which quarters have data, plus the academic calendar

list_departments

Department codes (CS resolves to COMPSCI)

Judging a class before you take it

Tool

What it answers

get_course_grades

Grade distribution by instructor or by term — "which professor should I take?"

get_instructor

A professor's courses and the grades they actually give

get_rmp_ratings

Rate My Professors average, review count and profile link for instructors teaching in a term

get_enrollment_history

Day-by-day fill curves — "will I get in?"

get_syllabi

Links to syllabi from past offerings — real workload and grading breakdown

get_course_materials

Required and recommended textbooks, with ISBNs and UCI Library links

Checking you can actually enrol

Tool

What it answers

check_prerequisites

Walks the prerequisite tree against what you've completed

check_schedule

Meeting conflicts, final-exam conflicts, total units, and whether the set is actually enrollable — missing discussions/labs, cancelled or full sections, TBA meetings

get_ap_credit

What an AP score is worth: units, GE, courses cleared

Planning a degree

Tool

What it answers

get_program_requirements

Degree requirement trees, including university-wide GE

check_degree_progress

Deterministic progress check from completed courses and AP scores; keeps uncertain rules visibly unverified

list_programs

Majors, minors, specializations

get_sample_program

The catalogue's recommended quarter-by-quarter sequence

Five of these compute things the upstream API does not provide: prerequisite-tree evaluation, schedule conflict detection, the join between the live schedule and historical grade data, AP-grant rendering, and deterministic degree-progress evaluation.

All 20 are annotated readOnlyHint: true — nothing here mutates anything.

Prompts (6)

In Claude Desktop these appear as slash commands. Each one drives a full multi-tool workflow rather than a single lookup.

Prompt

Arguments

What it does

plan-quarter

term*, goals

Builds a complete conflict-free schedule from scratch

pick-professor

course*, term

Compares instructors by grades, then by who's actually teaching

find-easy-ge

term, ge, constraints

Finds a GE that fits your schedule and grades well

check-my-schedule

term, sections

Validates section codes for conflicts, units and enrollment risk

can-i-take

course*, completed

Checks eligibility, including AP substitutions

degree-check

major*, completed, apScores

Runs the deterministic progress check, then plans what remains

* = required. Arguments named term, ge, department, major and course offer autocomplete through the MCP completions API.

Resources (4)

Reference tables your client can read directly, without spending a tool call:

  • anteater://reference/departments — every department code and name

  • anteater://reference/terms — every term with schedule data

  • anteater://reference/ge-categories — GE codes and what they mean

  • anteater://reference/restriction-codes — enrollment restriction codes, per the Registrar


Configuration

API key

Optional, but recommended: anonymous calls draw on a shared hourly quota that is easy to exhaust, and a key gives you your own.

It will not unlock fuzzy search. /v2/rest/search rejects ordinary keys with not permitted to access this resource — it needs elevated permission ICSSC grants separately. Without it search_courses falls back to substring matching on title, then description, and says so in its output. The structured filters (department, geCategory, courseLevel, units) are unaffected and are usually the better tool anyway.

  1. Go to dashboard.anteaterapi.com/create

  2. Choose type secret — publishable keys are verified against the Origin header, which Node does not send, so they will not work here

  3. Either set it in your client config (see above), or for local development:

cp .env.example .env     # then edit .env
set -a; . ./.env; set +a # load it without echoing the value

.env is gitignored. Never paste a key into an issue, PR or screenshot.

Shared and personal upstream keys (MCPHub)

For direct execution inside MCPHub, import the stdio configuration in the MCPHub guide. Each user can bind a personal key, and a separate shared entry uses the public/default key. No independent Anteater container is required. The following header mechanism is for HTTP deployments.

HTTP calls can use either the deployment's shared ANTEATER_API_KEY or a personal key sent as X-Anteater-Api-Key. The personal header takes precedence for that request, including all of its concurrent upstream calls. If the header is absent, the shared key is used (or anonymous upstream access if no shared key is configured). A blank or ambiguous personal header is rejected; an invalid personal key never retries with the shared key. Anteater API caches are separated by credential.

Authorization: Bearer <ANTEATER_MCP_TOKEN> still authenticates access to this server. It is independent of the upstream API key and is required for both modes when configured. Personal keys belong in headers, never URL query parameters.

See MCPHub setup for separate Shared and Personal server entries. Personal entries require a binding; Shared remains available without one.

Environment variables

Variable

Purpose

ANTEATER_API_KEY

Your secret key. See above.

ANTEATER_API_KEY_SCOPE

operator (default) or user. Says whose key ANTEATER_API_KEY is, which decides how its rejection is reported (see Errors). Set user when each user's own key is injected as the environment, one process per user. A key sent in X-Anteater-Api-Key is always the user's.

ANTEATER_API_BASE

Defaults to https://anteaterapi.com. Point at a self-hosted instance.

ZOTCOURSE_API_BASE

Independent fallback for live WebSoc schedule queries. Defaults to https://zotcourse.appspot.com; set to off to disable. Only search_sections, check_schedule and recommend_courses use it, and fallback results are labelled as potentially cached.

ANTEATER_MCP_TOKEN

HTTP mode only, and required before you expose the server. Clients send Authorization: Bearer <token>, which is preferred, or use https://host/mcp?token=<token> where the client accepts only a URL. Any token in a URL can land in browser history, connector settings, and proxy logs. /health stays open. Unset means no authentication, which is only safe on loopback.

ANTEATER_ALLOWED_ORIGINS

HTTP mode only. Comma-separated extra origins to allow.

ANTEATER_TRUSTED_PROXIES

HTTP mode only. Which direct peers may set X-Forwarded-*. Accepts CIDRs, bare addresses, and the shorthands private and loopback. Unset means the headers are ignored, because they are client-supplied and would otherwise let anyone forge their address in your log. Behind a reverse proxy set this, or every request looks like it came from the proxy. private covers the Docker bridge.

HOST / PORT

HTTP mode only; equivalent to --host / --port.

Command line

node anteater-mcp.mjs                    # stdio (what MCP clients use)
node anteater-mcp.mjs --http             # HTTP on 127.0.0.1:8787, endpoint /mcp
node anteater-mcp.mjs --http --port 9000 # different port
node anteater-mcp.mjs --http --host 0.0.0.0  # bind all interfaces (warns; see below)
node anteater-mcp.mjs --list-tools       # list every tool

HTTP mode security

  • Binds 127.0.0.1 by default. server.listen(port) with no host binds every interface, which would expose an unauthenticated server to the whole LAN. --host is required to change that, and it warns when you do.

  • Validates Origin. The MCP specification requires this of local HTTP servers: without it, any page you visit can POST to your port and drive every tool (DNS rebinding / CSRF). Requests with no Origin — native MCP clients — are allowed; requests with one must be localhost or listed in ANTEATER_ALLOWED_ORIGINS.

  • Access-Control-Allow-Origin echoes the single validated origin, never *.

  • Unauthenticated unless ANTEATER_MCP_TOKEN is set. That is fine on loopback and not fine anywhere else; the server warns at startup if it is bound off-loopback without one. See DEPLOY.md.

  • HTTP activity is logged to stderr as one JSON request line and one response line. Logs include a request ID, method, sanitized target, remote address, status, duration, RPC/tool name, and outcome when available. Authorization values and RPC arguments are never logged; URL token values are shown as [REDACTED].

  • /health reports status and the source URL; /source redirects to this repository, which helps anyone deploying a modified copy comply with AGPL section 13.


Errors

A failed tool call returns isError: true and a single text content item holding a JSON object, so a client can tell a bad credential from a service outage without parsing prose:

{"error": "RATE_LIMITED", "message": "Anteater API rate limit hit. Wait a moment, or set ANTEATER_API_KEY ...", "retry_after_seconds": 30}

error

Meaning

CREDENTIAL_INVALID

The requesting user's own key was rejected: Anteater API answered a JSON 401 (or a JSON 403 whose body says the key is invalid) to a key sent in the X-Anteater-Api-Key header, or to ANTEATER_API_KEY when ANTEATER_API_KEY_SCOPE=user.

PERMISSION_DENIED

Anteater API answered a JSON 403: the key is valid but not allowed to use that endpoint.

RATE_LIMITED

Anteater API answered 429. retry_after_seconds is present only when the upstream sent Retry-After.

INVALID_ARGUMENT

The tool input was wrong: a missing or malformed argument, an unknown department or term, a course that does not exist (upstream 404), or an upstream 400/422.

SOURCE_UNAVAILABLE

Network failure, timeout, 5xx, a non-JSON reply (for example a WAF or CDN challenge page, including a non-JSON 401/403), any other unexpected fault, or the server's own configured key being rejected (ANTEATER_API_KEY with the default operator scope, or no key at all): the operator must fix it, not the caller.

message stays human-readable and is safe to show to a user; it never contains the API key. Codes are stable; wording is not.

The REST facade (/tools/<name>) keeps HTTP 200 with {"result": ..., "isError": true} for a tool failure. result is the same JSON string as the MCP text, and a top-level "error": "<CODE>" repeats the code. Transport problems keep their HTTP status but now share one body shape, {"error": "<CODE>", "message": "<text>"}, with error one of INVALID_ARGUMENT (400), UNAUTHORIZED (401), NOT_FOUND (unknown tool, 404), METHOD_NOT_ALLOWED (405) or PAYLOAD_TOO_LARGE (413). A failing resources/read keeps JSON-RPC error -32603 and adds data: {"error": "<CODE>"}. All of this is described in /openapi.json. The static gpt-actions-openapi.json talks to Anteater API directly and is unaffected.

Changes

1.0.0-beta.3

  • Tool failures are now structured. The text content of an isError result is a JSON object {"error": CODE, "message": text} instead of Error: ... prose. Codes: CREDENTIAL_INVALID, PERMISSION_DENIED, RATE_LIMITED, INVALID_ARGUMENT, SOURCE_UNAVAILABLE.

  • REST facade result format change. On failure, /tools/<name> still returns HTTP 200 with isError: true, but result is now that JSON string rather than Error: ... prose, and a top-level error code is added. Transport errors (400, 401, 404, 405, 413) now return {"error": CODE, "message": text} where some returned plain text or {"error": text}. Match on error, not on the old Error: prefix.

  • New ANTEATER_API_KEY_SCOPE (operator default, or user).

  • get_course, check_prerequisites no longer report an upstream outage or rate limit as "No course ...": only a real 404 does.


Troubleshooting

Symptom

Cause and fix

Tools don't appear in Claude Desktop

The path must be absolute, and you must fully quit and reopen the app. Check the config parses: node -e "require('./claude_desktop_config.json')".

RATE_LIMITED (Anteater API rate limit hit)

The anonymous quota is shared and replenishes hourly. Set ANTEATER_API_KEY.

CREDENTIAL_INVALID

Your own API key was rejected. Replace the X-Anteater-Api-Key header value (or your personal key binding).

SOURCE_UNAVAILABLE saying the server's configured key was rejected

Operator: replace ANTEATER_API_KEY.

search_courses returns odd results

Fuzzy search needs a privileged key that ordinary keys are not granted; it falls back to substring matching and says so. Use the structured filters instead.

Too broad from search_sections

A whole term is tens of thousands of sections. Add department, courseNumber, ge, instructor or sectionCodes.

"2026 summer" is ambiguous

UCI has three summer terms. Use Summer1, Summer2 or Summer10wk.

Unknown department "..."

Use list_departments, or read anteater://reference/departments.

A course has no grade data

Recent quarters lag, and P/NP-only courses have none.

Seats look stale

Live figures are cached for 5 minutes; the catalogue for 24 hours.

Schedule fallback appears

Anteater API was unavailable, so the schedule came from Zotcourse's WebSoc-backed endpoint. Verify seats and section pairing in WebReg. Set ZOTCOURSE_API_BASE=off if you do not want this network fallback.


Development

npm test                # 20 conformance tests; makes no API calls
npm run test:live       # live calls; needs a key in practice
npm ci                  # build tooling only; the shipped server has no runtime packages
npm run build:sea       # standalone binary; requires the exact Node in .node-version

UPSTREAM.md records the exact Anteater API version and the upstream commits this server was validated against, endpoint by endpoint — start there when the API changes and something begins returning wrong or empty results.

VERIFICATION.md is a full release checklist — per-regression pass criteria, security checks and integration checks — written so someone who has never read the code can run it.

CI uses the same pinned Node 24 LTS release as Docker and native packaging. It runs the offline suite, syntax and OpenAPI checks, a standalone-executable smoke test, and a locked-down container protocol test. It deliberately makes no live Anteater API calls, so it never draws on the public rate limit.

Pushing a tag that exactly matches v plus the package.json version builds six native executables, generates checksums and provenance attestations, pushes an amd64/arm64 image to GHCR, and publishes the GitHub Release. Stable tags update :latest; every release updates :beta; exact :vX.Y.Z tags are immutable.

After the first image publish, set the GHCR package visibility to Public once. The workflow uses the scoped GITHUB_TOKEN; if repository policy blocks bot-created Releases, add a fine-grained RELEASE_PAT secret with Contents write access, matching the upstream project's fallback.

Scope

Anteater API also serves dining halls, library traffic and study-room bookings. Those are deliberately not wrapped — this server stays focused on choosing and registering for classes.

LARC tutoring sections are in scope but effectively dead upstream: /v2/rest/larc returns 22 courses for 2024 Fall and nothing for any term since, so a tool would always answer "none" for the term a student is actually planning.


Known limitations

These are properties of the upstream data, not bugs. The server states them rather than papering over them, because the alternative is confident wrong advice.

  • WebSoc does not publish which discussion belongs to which lecture. Some courses encode it in the section number (Lec A → Dis A1), others number companions independently (I&C SCI 31: lectures A/B, labs 1–9). check_schedule therefore tells you when a required component is missing entirely, and when a pairing cannot be verified — but it cannot confirm that a given lab goes with a given lecture. Confirm that on WebReg. Neither of ICSSC's own clients infers this either: AntAlmanac and PeterPortal both render sections as a flat list and leave the pairing to the student, which is good evidence the data simply is not there.

  • Enrollment restrictions are not evaluated against you. search_sections and recommend_courses surface the codes and their meanings; whether you satisfy "Major only" or "Graduate only" is enforced by the registrar.

  • Transfer and community-college coursework is absent. check_prerequisites reports any completed course it does not recognise instead of silently ignoring it, but only an advisor can clear transfer credit.

  • No registration-window dates. The academic calendar covers instruction and finals; it does not say when your enrollment window opens. Check StudentAccess.

  • Grade data lags. Recent quarters may be missing, and a recent term's grades are often filed under STAFF. A small sample size makes an average GPA unreliable — the tools always print n so you can judge.

  • Historical GPA is course-wide. recommend_courses ranks by the average across all past instructors, which may not be whoever is teaching this term. Use get_course_grades to check the specific instructor before deciding.

Bugs found and fixed before release

A six-dimension parallel review (logic, MCP conformance, live-API contract, security, robustness, repo readiness) produced 41 raw findings, 38 after deduplication. The ones that would actually have misled someone:

Bug

Consequence

A bare null JSON-RPC message killed the process

Both transports. Over HTTP that was an unauthenticated 4-byte denial of service.

Every final exam date was one month early

WebSoc's finalExam.month is 0-indexed (11 = December); the code treated it as 1-indexed. "Tue Nov 8" was really December 8 — someone books a flight on the wrong date.

7 of 19 restriction codes were wrong

K was labelled "Cross-listed" but means Graduate only, and appears 608 times in a single term. X was "Separate final exam" but means authorization codes are needed even to drop.

"2026 Summer 1" silently returned Spring

The bare s alias swallowed summer. Three of six quarters were unreachable by natural phrasing, and it returned a confident, entirely wrong schedule.

Standalone lab courses counted as 0 units

check_schedule excluded Lab sections, so CHEM 1LD (3 units, no lecture) vanished — a student could misjudge the 12-unit full-time threshold that gates financial aid and F-1 status.

recommend_courses forced sectionType: Lec

Every seminar-only GE was invisible; GE-1A returned nothing at all.

get_program_requirements with ugrad always failed

The endpoint has a required id parameter the tool never sent.

HTTP mode bound 0.0.0.0 without validating Origin

While logging "listening on localhost".

Fall sorted as the earliest term of its year

Reversed the chronology in get_enrollment_history and get_course_grades.

A second round, driving the server through six realistic student scenarios end to end, found 54 more — 10 of them blockers. The worst:

Bug

Consequence

check_schedule gave a clean all-clear to unenrollable schedules

It checked only times. A lecture with no required lab, or a full or cancelled section, passed silently — the student would be rejected at WebReg.

days meant "meets on at least one of"

A student who could only attend Tu/Th was shown three- and four-day courses, and courses whose mandatory labs were all MWF.

A bare instructor surname matched nothing

get_course_grades blamed the course — "may be new or graded P/NP only" — for a professor with 1,642 grades on record.

Degree requirements defaulted to the 2023–2024 catalogue

Three years stale, with no indication, for a student on 2026–2027.

check_prerequisites silently dropped unrecognised courses

Then printed a confident "NOT satisfied" for work the student had actually done.

recommend_courses hid restriction codes

Its highest-ranked GE picks were courses the student could not enrol in.

check_schedule threw a raw TypeError

When given the comma-separated string that search_sections documents for the same parameter name.

Also fixed: inverted check marks in NOT prerequisite subtrees, course numbers lost for the 48 department codes containing a space, multi-byte UTF-8 corrupted across HTTP chunk boundaries, a quadratic-backtracking regex on unvalidated input, and socAvailable mislabelled as "enrollment opens" when it is the schedule publication date.

API quirks worth knowing

Undocumented upstream; all handled here, and listed in case they save you the debugging.

  • days must be comma-separated. Tu,Th works, TuTh is rejected. It matches at least one of the listed days, not all of them.

  • enrollmentHistory returns parallel arrays (dates[], totalEnrolledHistory[], requestedHistory[], …), not scalars. -1 means "not tracked".

  • finalExam.month is 0-indexed.

  • Course comments are raw HTML fragments, complete with <p> and &quot;.

  • startTime / endTime mean "starts at or after" and "ends at or before", not interval overlap.

  • /v2/rest/search needs a privileged API key. An ordinary key is refused with not permitted to access this resource, which is a different error from the key is required you get with no key at all — worth distinguishing, since telling someone who already has a key to get a key is a dead end.

  • /v2/rest/websoc/syllabi takes courseId, not department + courseNumber.

  • /v2/rest/courseMaterials needs department AND courseNumber together. Either alone is refused, and it collapses the three summer sessions into a single Summer.

  • Restriction strings contain prose. "A and N" must be split on whitespace and have the literal and/or discarded, or the conjunction renders as a code.

  • Section status is an enum, not free text: OPEN, Waitl, FULL, NewOnly, or empty. Only OPEN means a continuing student can enrol now — NewOnly marks seats held for incoming students. numNewOnlyReserved counts seats inside the capacity that are reserved the same way, so the apparent opening overstates the real one.


Distribution

Published to the MCP Registry as io.github.KKazuhaK/anteater-mcp, listing the container image only. The registry entry describes how to run your own instance; it does not point at anyone's deployment, since a hosted instance is gated behind its own token and its upstream quota belongs to whoever runs it.

Each release also publishes the GHCR image and standalone binaries for six platforms.

Licence and attribution

Data from Anteater API, maintained by ICSSC Projects.

This is not an official UCI tool. Verify on WebReg or the General Catalogue before registering. Use is subject to Anteater API's attribution policy.

Licensed AGPL-3.0-or-later, matching the upstream Anteater API server so code can move freely in either direction if this is ever contributed upstream. This is an independent HTTP client and contains no upstream source code. If you modify it and run it as a network service, AGPL section 13 requires you to offer users your Corresponding Source — see NOTICE.

For academic use:

@misc{anteater-api,
  author = {ICS Student Council},
  title = {Anteater API},
  year = {2024},
  howpublished = {\url{https://github.com/icssc/anteater-api}},
}

Available Tools

16 tools
ap_creditWhat an AP exam is worth at UCIA
Read-onlyIdempotent

Look up what AP exam scores earn at UCI: units, elective units, GE categories and specific courses cleared. Use for incoming students planning a first quarter, or to work out whether an exam score already satisfies a prerequisite. The catalogueName in the output is the exact string check_prerequisites expects in apScores.

Inputs: exam.

check_prerequisitesCheck whether you can take a courseA
Read-onlyIdempotent

Evaluate a course's prerequisite tree against the courses a student has already completed, showing exactly which requirements are met and which are missing. Also reports enrollment restrictions (major-only, etc.), which the API cannot verify automatically.

Inputs: courseId (required), apScores, completed.

check_scheduleCheck a set of sections for conflictsA
Read-onlyIdempotent

Given a term and a list of 5-digit section codes, build the weekly timetable, total the units, and report any meeting-time or final-exam conflicts. Use this to validate a proposed schedule before registration.

Inputs: term (required), sectionCodes (required).

course_gradesGrade distribution for a courseA
Read-onlyIdempotent

Historical grade distributions and average GPA for a course, broken down by instructor (default) or by term. Use this to answer 'which professor should I take?' or 'how hard is this class?'. Data is from UCI's public records; recent quarters may be missing.

Inputs: year, groupBy, quarter, courseId, +4 more.

enrollment_historyHow fast a class fills upA
Read-onlyIdempotent

Historical enrollment for a course: final enrollment vs capacity, waitlist size, and (for recent terms) the day-by-day fill curve. Use this to judge registration risk — 'will I get in?', 'do I need to enroll at 7am?', 'does the waitlist clear?'.

Inputs: year, quarter, courseId, showCurve, +4 more.

find_sectionsFind class sections in a term (WebSoc)A
Read-onlyIdempotent

The main course-finding tool. Queries UCI's live schedule of classes for one term and returns matching sections with meeting times, instructor, location, seats taken, waitlist and final exam. Filter by department, course number, GE category, instructor, days of week, time window, and seat availability. At least one narrowing filter besides the term is required.

Inputs: term (required), ge, days, limit, +17 more.

get_courseGet full course detailsA
Read-onlyIdempotent

Full catalogue detail for one course: description, units, prerequisites (text and structure), courses that unlock from it, enrollment restrictions, GE credit, repeatability, and which terms it has been offered. Use this before advising someone to take a course.

Inputs: courseId (required).

get_program_requirementsGet degree requirementsA
Read-onlyIdempotent

The full requirement tree for a major, minor or specialization, or the university's general undergraduate requirements (GE categories, unit minimums). Use for degree planning — 'what do I still need?'.

Inputs: kind, block, programId, catalogYear, +1 more.

get_syllabiFind past syllabi for a courseA
Read-onlyIdempotent

Links to syllabi from previous offerings of a course, by term and instructor. Use to show a student what the workload, grading breakdown and topics actually look like before they enroll. Links point at UCI Canvas and may require a UCInetID login.

Inputs: courseId (required), year, quarter, instructor.

instructor_infoLook up an instructorA
Read-onlyIdempotent

Find a UCI instructor and see their title, department, the courses they have taught, and their average GPA given across all courses. Use to evaluate a professor before enrolling.

Inputs: name, ucinetid, includeGrades.

list_departmentsList department codesA
Read-onlyIdempotent

List UCI department codes used by the schedule of classes (e.g. COMPSCI, I&C SCI, BIO SCI). Use when you are unsure of the exact code for a subject. Optionally filter by a substring.

Inputs: filter.

list_programsList majors, minors and specializationsA
Read-onlyIdempotent

List UCI degree programs. Use to find the program id needed by get_program_requirements.

Inputs: kind, filter.

list_termsList terms and academic calendarA
Read-onlyIdempotent

List the UCI terms (quarters) that have schedule-of-classes data, plus the current week of instruction. Optionally pass a term to get that term's academic calendar (instruction begins/ends, finals week, holidays). Call this first when the user says 'next quarter' or doesn't name a term.

Inputs: term.

recommend_coursesRecommend courses matching constraintsA
Read-onlyIdempotent

The 'find me a class' tool. Combines the live schedule with historical grade data to rank candidate courses for a term. Filter by GE category, department, level, days of week, time window and seat availability; results are ranked by historical average GPA (or by open seats). Ideal for 'find me an easy GE-2 with open seats that doesn't meet before 10am'.

Inputs: term (required), ge, days, limit, +7 more.

sample_programSample four-year plan for a majorA
Read-onlyIdempotent

The catalogue's recommended quarter-by-quarter course sequence for a major. Use to answer 'what should I take first year?' or to sanity-check whether a student is on track. Call with no argument to list the majors that have a published plan.

Inputs: program.

search_coursesSearch the course catalogueA
Read-onlyIdempotent

Search the UCI course catalogue (all courses that exist, not term-specific offerings). Use a free-text query for fuzzy search ('machine learning', 'CS 161'), or the structured filters to browse (e.g. all GE-2 lower-division courses worth 4 units). To see which sections actually run in a given quarter and whether seats are open, use find_sections instead.

Inputs: limit, query, maxUnits, minUnits, +6 more.

Tool Schema Changelog

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

Loading tool schema changelog…

    TDQS

    A4.1/5.0

    Scored across 16 tools

    Disambiguation4/5

    Most tools target distinct resources and workflows; course lookup is split between catalogue search, live section search, and ranked recommendation, but descriptions explicitly steer usage. A few adjacent tools (course_grades vs instructor_info, sample_program vs get_program_requirements) could be confused in edge cases.

    Naming Consistency4/5

    The dominant verb_noun pattern (list_, search_, get_, find_, check_, recommend_) is clear and predictable. Four noun_noun names (ap_credit, course_grades, instructor_info, enrollment_history) are minor deviations rather than a break in readability.

    Tool Count4/5

    16 tools is at the high end, but each maps to a distinct aspect of UCI course planning: catalogue, sections, grades, instructors, prerequisites, schedules, syllabi, and degree requirements. It feels broad rather than padded, though a slightly leaner set might combine some grade/enrollment lookups.

    Completeness5/5

    For a read-only academic-advising server, the surface covers the main workflows: discovering programs/requirements, searching and validating courses, checking prerequisites and schedules, and evaluating instructors via grades and history. There are no obvious dead ends; list_programs and list_terms feed the tools that need IDs and terms.

    Maintenance

    ActivityMaintained
    ResponsivenessOutdated data

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      B
      quality
      D
      maintenance
      Enables Claude to interact with core AWS services like S3, EC2, RDS, and CloudWatch, along with a generic SDK wrapper for any AWS operation. It also supports cost monitoring and optional vector store capabilities for document ingestion and search.
      10
      3
      -
    • A
      license
      C
      quality
      B
      maintenance
      Provides 40 tools to Claude for Wikipedia citation analysis, edit history, and DOI/ISBN annotation, enabling citation quality scoring and metadata enrichment without leaving the chat.
      38
      29 PyPI
      1
      MIT
    • A
      license
      B
      quality
      C
      maintenance
      Enables a local-first MBA recruiting coach inside Claude that remembers your campaign, tracking target firms, live job boards, deadlines, applications, connections, and warm intros, while drafting human-approved outreach and never submitting applications or scraping LinkedIn.
      23
      MIT