This server lets AI assistants and API clients securely access a student's METU SAIS data and manage connection records through MCP tools and a REST API.
Fetch student info: ID, name, department, semester, GPA/CGPA, academic status, and advisor.
Fetch weekly class schedule, optionally filtered by a semester code.
Fetch full academic transcript with courses, credits, grades, and semester GPA history.
Fetch current METU SAIS portal announcements.
Create in-memory connection records.
List existing connection records.
Works as an MCP server over stdio, SSE, or Streamable HTTP for tools like Claude Desktop, Cursor, and OpenCode.
Provides a FastAPI REST backend with endpoints for info, schedule, transcript, announcements, and connection CRUD.
Supports multi-tenant remote usage where users pass credentials per-session via headers, Basic Auth, or query parameters without storing passwords.
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., "@metu-sais-mcp What's my current GPA and class schedule?"
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.
A modern Model Context Protocol (MCP) server and FastAPI service for Middle East Technical University (METU / ODTÜ) Student Affairs Information System (SAIS / student.metu.edu.tr).
Connects your AI assistants (such as OpenCode, Claude Desktop, and Cursor) directly to METU SAIS with real authentication, structured data parsing, and stateless multi-tenant remote streaming.
Multi-Tenant Architecture: Supports both local single-user runs and remote multi-tenant serving over Server-Sent Events (SSE) / HTTP. Remote users pass their own credentials via headers or query parameters without storing any passwords on the server.
SSO Authentication: Handles the real METU SSO login flow (/sso/backend/request/user/signin) and session token validation.
Proxy Scraper & HTML Parser: Automatically establishes authenticated proxy sessions (/proxy/Student_Information/) and parses student records into structured JSON.
MCP Server (MCP SDK): Exposes typed tools over standard I/O (stdio), Server-Sent Events (sse), or Streamable HTTP.
FastAPI REST Service: Alternative HTTP REST backend for API integrations.
Privacy & Security: Zero credential logging or exposure.
Related MCP server: SABIS MCP Server
Tool | Description |
| Fetches student ID, name, department, semester, GPA/CGPA, academic status, and advisor. |
| Fetches weekly class schedule (days, hours, course codes, course names, classrooms, instructors). |
| Fetches academic transcript across all semesters with courses, credits, grades, and semester GPA statistics. |
| Fetches active portal announcements. |
| Creates an in-memory connection record. |
| Lists all saved connection records. |
Python >= 3.11
uv (recommended) or pip
# Using uv (recommended)
uv sync
# Or using pip
pip install -e .For local single-user runs, copy .env.example to .env:
cp .env.example .envEdit .env:
SAIS_USERNAME=your_metu_username
SAIS_PASSWORD=your_metu_password
LOCALE=tr
PORT=8300.env is listed in .gitignore and will never be committed. Remote multi-tenant users do not need a .env file on the server because they supply their credentials per-session via request headers or URL parameters.
# Direct MCP SSE server:
uv run metu-sais-mcp --transport sse --host 0.0.0.0 --port 8300
# Or via FastAPI (serves both REST API and MCP SSE at /sse and /messages/):
uv run uvicorn api.main:app --host 0.0.0.0 --port 8300{
"mcpServers": {
"metu-sais": {
"url": "https://mcp.yourdomain.com/sse",
"headers": {
"X-SAIS-Username": "e123456",
"X-SAIS-Password": "student_secret_password"
}
}
}
}{
"mcpServers": {
"metu-sais": {
"url": "https://mcp.yourdomain.com/sse",
"headers": {
"Authorization": "Basic <base64(username:password)>"
}
}
}
}{
"mcpServers": {
"metu-sais": {
"url": "https://mcp.yourdomain.com/sse?u=e123456&p=student_secret_password"
}
}
}When starting OpenCode inside this repository:
opencodeOpenCode will automatically connect to the metu-sais MCP server defined in opencode.json.
uv run metu-sais-mcpTo start the FastAPI server:
uv run uvicorn api.main:app --port 8300 --reloadInteractive API documentation will be available at:
Swagger UI: http://localhost:8300/docs
Health check: http://localhost:8300/healthz
GET /api/sais/info — Student information
GET /api/sais/schedule — Class schedule
GET /api/sais/transcript — Transcript history
GET /api/sais/announcements — Portal announcements
GET|POST|PUT|DELETE /api/connections — Connection management CRUD
(In multi-tenant mode, pass X-SAIS-Username and X-SAIS-Password headers or ?u=...&p=... query parameters to any REST endpoint).
Run the automated test suite with pytest:
uv run pytest -vThe test suite includes:
Unit tests for HTML parsers (parse_student_info, parse_schedule, parse_transcript, parse_announcements).
MCP tool registration and tool calling tests.
Multi-tenant credential extraction and session isolation tests.
FastAPI REST endpoint tests.
Live integration tests against METU SAIS when credentials are configured.
├── sais/
│ ├── auth.py # Multi-tenant credential resolver and session store
│ ├── connector.py # Core SAIS authentication, proxy scraping, and HTML parsers
│ └── connections.py # Shared in-memory connection store
├── sais_mcp/
│ └── server.py # MCP multi-tenant server (stdio, sse, streamable-http)
├── api/
│ └── main.py # FastAPI REST API + mounted MCP SSE app
├── tests/
│ ├── test_connector.py # Scraper and HTML parser tests
│ ├── test_mcp_server.py# MCP server and multi-tenant SSE isolation tests
│ └── test_api.py # FastAPI tests
├── .env.example # Environment variable template
├── opencode.json # OpenCode MCP configuration
├── pyproject.toml # Package dependencies and CLI entrypoints
└── README.md # Project documentationMIT License.
Yeni bir bağlantı kaydı oluşturur.
| Name | Required | Description | Default |
|---|---|---|---|
| name | Yes | ||
| description | No |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must carry the behavioral burden, but it only says 'creates a new connection record.' It does not disclose duplicate handling, required permissions, idempotency, or any side effects beyond the basic creation action.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single short sentence with no filler, repetition, or unnecessary detail. It is front-loaded and every word earns its place, even though the overall content is minimal.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Although the output schema removes the need to document return values, this is a state-changing tool with no annotations and no usage or parameter guidance. The description lacks context about what a connection record represents, when to create one, and what happens on duplicate or invalid input, so it is not complete enough for confident invocation beyond the basic action.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, and the description adds no meaning to the 'name' or 'description' parameters. It does not clarify what a valid name should be, whether names must be unique, or how the description field is used, so it provides no value beyond the schema's property titles.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a distinct action ('Yeni bir bağlantı kaydı oluşturur' / creates a new connection record) with a clear verb and resource. Among sibling tools, it is the only create-style action, so an agent can distinguish it from list_connections and the various get_* tools without opening the schema.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives no guidance about when to use this tool versus list_connections or other siblings. It only defines the action, leaving the agent to infer prerequisites, typical triggers, or alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
METU SAIS öğrenci portalındaki güncel duyuruları alır.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the behavioral disclosure burden. It signals a read-only retrieval action ('alır') and restricts scope to 'current' announcements, but it does not mention authentication needs, caching, or any other operational traits. This is acceptable for a zero-parameter fetch but not richly transparent.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence with no filler. Every word contributes to identifying the source and content of the tool.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is very simple (no parameters, output schema present), so the description covers the basic action. However, it omits any context about whether an existing connection or authentication is required, which is relevant given sibling tools create_connection and list_connections. The absence of annotations makes this a modest gap.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has zero parameters and 100% coverage, so there are no parameter semantics to clarify. The baseline for a zero-parameter tool is 4, and the description adds no conflicting parameter information.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly identifies the action ('alır' / gets) and the resource ('METU SAIS öğrenci portalındaki güncel duyurular' / current announcements from the METU SAIS student portal). It is specific but does not explicitly differentiate from sibling tools like get_schedule or get_transcript, though the announcement subject is distinctive.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives, nor any exclusions or prerequisites. The name and resource imply 'use when you need announcements,' but the description does not state this or mention sibling tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
METU SAIS'ten haftalık ders programını alır. Belirli bir dönem kodu (ör. '20251|1') verilebilir.
| Name | Required | Description | Default |
|---|---|---|---|
| semester | No |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full behavioral disclosure responsibility. It mentions an optional semester code but does not disclose default behavior when omitted, authentication needs, rate limits, or any other operational characteristics.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two short sentences with the main purpose front-loaded and the optional parameter explained second. Every word earns its place; there is no redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple retrieval tool with an output schema and one optional parameter, the description is adequate for basic invocation. However, it lacks usage context and default behavior, making it minimally viable rather than fully complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0%, but the description partially compensates with a concrete example semester code ('20251|1') and clearly indicates the parameter is optional. It does not explain what null means or fully define the accepted format.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb ('alır' – retrieves) and a specific resource: the weekly course schedule from METU SAIS. It is clearly distinct from sibling tools like get_transcript and get_announcements, though it does not explicitly contrast itself with them.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is given about when to use this tool versus alternatives, and there are no exclusions or conditions. An agent must infer usage solely from the resource name.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
METU SAIS'ten öğrenci temel bilgilerini, danışmanını, GPA/CGPA ve kayıt durumunu alır.
| Name | Required | Description | Default |
|---|---|---|---|
| semester | No |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description conveys a read-only retrieval operation and lists the data included, which is useful behavioral content. However, with no annotations provided, it does not disclose connection/auth requirements, semester handling, or possible error behavior, leaving meaningful gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single concise sentence with no filler. It front-loads the source and the key data scopes, so it is easy to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the simple one-parameter schema and no annotations, the description is incomplete because it omits the only parameter's semantics and any dependency on connections. The output schema may explain return structure, but behavioral and invocation context remain underspecified.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0% and the description never mentions the 'semester' parameter. The agent receives no explanation of the semester value format, whether it is needed, or how it affects the returned GPA/CGPA and registration status.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('alır') and names a concrete resource: student basic info, advisor, GPA/CGPA, and registration status from METU SAIS. It is clear what the tool returns, though it does not explicitly contrast itself with sibling tools like get_schedule or get_transcript.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is given about when to use this tool instead of alternatives such as get_transcript or get_schedule. There are no conditions, exclusions, or prerequisites mentioned, so the agent must infer usage solely from the tool name and sibling names.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
METU SAIS'ten tüm dönemleri, alınan dersleri, harf notlarını, kredileri ve GPA geçmişini (transkript) alır.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It explicitly says the tool retrieves all semesters and the full transcript data, making the operation's scope clear. It does not discuss auth, rate limits, or failure modes, but for a zero-parameter read operation the enumerated retrieval behavior is sufficient.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single dense sentence leads with the source and then lists the exact data elements. There is no filler, no repetition of the tool name, and every phrase adds information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a no-parameter getter with an output schema, the description covers the source and contents well, and return values are likely already documented by the output schema. The only minor gap is that it does not mention whether an existing connection is required, especially given sibling tools like create_connection and list_connections.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, so there are no parameter semantics for the description to clarify. The baseline score of 4 applies, and the description appropriately focuses on what data is returned rather than input options.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific action ('alır' - gets), a specific resource (METU SAIS transcript), and enumerates the exact contents: all semesters, courses, letter grades, credits, and GPA history. This clearly differentiates it from siblings like get_student_info and get_schedule.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description clearly implies the tool should be used when a transcript is needed, but it never explicitly states when to use it versus alternatives or when not to use it. Sibling tools such as get_student_info and get_schedule could partially overlap, so an explicit routing hint would help, but the context is reasonably clear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Mevcut tüm bağlantı kayıtlarını listeler.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the burden of behavioral disclosure. It communicates a read-only 'list all' operation, which is useful, but it adds no further behavioral context such as ordering, scope limitations, or pagination. The output schema presumably covers return shape.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single front-loaded sentence with no filler. Every word contributes to identifying the action and resource.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a parameterless read-only list tool with an output schema, the description is largely complete. The main gap is that the term 'connection records' is left ambiguous, but the operation itself is fully specified.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, so the input schema is empty and there are no parameter semantics to explain. The baseline for zero-parameter tools is 4, and the description does not need to compensate for anything.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('listeler'/'lists') and identifies the resource ('bağlantı kayıtları'/'connection records'), making the tool's purpose reasonably clear. It does not fully define what a 'connection' is in this domain, so it falls short of a 5.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is given about when to use this tool instead of siblings like create_connection. There is no stated context, prerequisite, or exclusion, so the agent must infer usage entirely.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
v0.1.0create_connectionget_announcementsget_scheduleget_student_infoget_transcriptlist_connectionsScored across 6 tools
Each tool targets a clearly distinct resource or action: student info, schedule, transcript, announcements, and connection records. There is no meaningful overlap that would cause an agent to select the wrong tool.
Tool names follow a consistent snake_case verb_noun pattern: get_student_info, get_schedule, get_transcript, get_announcements, create_connection, list_connections. The only minor variation is singular vs plural nouns, but the pattern is predictable.
Six tools is a well-scoped set for a student portal MCP server. It covers the core read operations and adds connection management without bloating the surface.
The student-facing read operations are solid, but connection management is incomplete: create_connection and list_connections have no corresponding update or delete operation, creating a lifecycle dead end. Minor gaps like course-level detail or exam results are less critical but still absent.
MCP server connecting AI agents to 100+ apps (Gmail, Slack, Notion, GitHub) via one-click OAuth.
Zero-setup MCP gateway securely connecting AI to your tools with authentication and workflows
Automate 1,000+ services from any MCP-compatible AI agent: build Applets, run actions and queries.
Let AI agents query data and act across all your business apps via MCP.
