sio-mcp

by noah-lowry

Overview Schema Related Servers Score Discussions

Python

Local

Server Quality Checklist

Profile completionA complete profile improves this server's visibility in search results.

Latest release: v0.1.0
Disambiguation4/5
Each tool targets a distinct data domain (schedule, grades, billing, etc.), but get_student_context and get_enrollment_status overlap on class level, major, and advisor. The descriptions clarify when to use which, so confusion is unlikely.
Naming Consistency5/5
Every tool follows the exact same get_<domain> pattern with clear, descriptive nouns. This is perfectly consistent and predictable.
Tool Count5/5
Eight tools is well within the ideal range for a student data server. Each tool covers a meaningful data area without redundancy or bloat.
Completeness5/5
The server covers the full read-only student information surface: context, schedule, grades, credits, enrollment, billing, and campus life. No obvious missing queries for the stated purpose.
Average 4.3/5 across 8 of 8 tools scored.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 1 commit in the last 12 weeks
- No stable releases found
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI status not available
Add a LICENSE file by following GitHub's guide. Once GitHub recognizes the license, the system will automatically detect it within a few hours.
If the license does not appear after some time, you can manually trigger a new scan using the MCP server admin interface.
MCP servers without a LICENSE cannot be installed.
This repository includes a README.md file.
No tool usage detected in the last 30 days. Usage tracking helps demonstrate server value.
Tip: use the "Try in Browser" feature on the server page to seed initial usage.
Add a glama.json file to provide metadata about your server.
If you are the author, simply .
If the server belongs to an organization, first add glama.json to the root of your repository:
```
{
  "$schema": "https://glama.ai/mcp/schemas/server.json",
  "maintainers": [
    "your-github-username"
  ]
}
```
Then . Browse examples.
Add related servers to improve discoverability.

How to sync the server with GitHub?

Servers are automatically synced at least once per day, but you can also sync manually at any time to instantly update the server profile.

To manually sync the server, click the "Sync Server" button in the MCP server admin interface.

How is the quality score calculated?

The overall quality score combines two components: Tool Definition Quality (70%) and Server Coherence (30%).

Tool Definition Quality measures how well each tool describes itself to AI agents. Every tool is scored 1–5 across six dimensions: Purpose Clarity (25%), Usage Guidelines (20%), Behavioral Transparency (20%), Parameter Semantics (15%), Conciseness & Structure (10%), and Contextual Completeness (10%). The server-level definition quality score is calculated as 60% mean TDQS + 40% minimum TDQS, so a single poorly described tool pulls the score down.

Server Coherence evaluates how well the tools work together as a set, scoring four dimensions equally: Disambiguation (can agents tell tools apart?), Naming Consistency, Tool Count Appropriateness, and Completeness (are there gaps in the tool surface?).

Tiers are derived from the overall score: A (≥3.5), B (≥3.0), C (≥2.0), D (≥1.0), F (<1.0). B and above is considered passing.

Tool Scores

Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true. The description adds valuable behavioral detail beyond annotations: amounts are USD decimal strings, charges are positive, payments and aid are negative, and data is grouped by fiscal year. This helps the agent interpret the result correctly.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is tight and well-structured: purpose first, then use conditions, then data format details. Every sentence adds useful information with no filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With an output schema present and only one optional boolean parameter, the description covers most operational context: what the tool returns, when to use it, and how values are signed. The only notable gap is the undocumented force_refresh parameter.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0% and the description does not mention the force_refresh parameter at all. The parameter's name and default give some hint, but the behavior and consequences of setting it to true are left entirely to inference. For a low-coverage schema, the description should compensate and does not.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly identifies the tool as a student account ledger and enumerates its contents (tuition, fees, housing, grants, loans, payments, running balance). It also gives explicit call intent, making the tool's purpose unmistakable even though it uses a noun phrase rather than a verb.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
It explicitly states when to call the tool: 'Call this when the user asks about their bill, balance, charges, payments, or financial aid disbursements.' It does not mention alternatives or exclusions, but none of the sibling tools appear to overlap with financial account activity.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, and the description adds that the tool returns housing assignment and Plaid Cash balance. It does not go deeper into data source, freshness, or response behavior, but for a simple read-only getter this is acceptable.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Extremely concise and front-loaded. The first line is a minor fragment ('Housing assignment, and Plaid Cash balance.'), but it immediately conveys the key resources, and the second line gives actionable usage guidance.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a no-parameter read-only tool with an output schema, the description is largely complete: it states what data is returned and when to call. It could mention the output schema or any limitations, but the structured schema covers return details.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, so the baseline is 4. There is no parameter information needed, and the description fully covers the absence of parameters by focusing on when to call.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly identifies the tool's scope: housing assignment and Plaid Cash balance, with explicit user intents ('asks where they live on campus or about their Plaid Cash'). This is specific enough to distinguish it from sibling tools like get_schedule and get_grades.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides explicit trigger conditions for when to call the tool. It does not discuss exclusions or alternatives, but the conditions are specific and cover the main use cases.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations only include readOnlyHint=true, so the description adds useful behavior: grades show 'NA' until posted, omitting `term` returns the current semester, and `available_terms` in the response lists other queryable terms. This goes beyond the annotation and helps set expectations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Three sentences with no redundancy: the first defines output, the second gives usage conditions, and the third covers behavioral nuances. The most important scoping information is front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the low parameter count, the output schema, and the readOnly annotation, this is nearly complete. The only notable gap is the undocumented `force_refresh` parameter, which prevents a 5.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. It does explain `term` well ('Omit `term` for the current semester; `available_terms` in the response lists what else can be queried'), but it says nothing about `force_refresh`. The parameter name and default are weakly indicative, but an explicit explanation would be needed for full clarity.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states a specific verb and resource: it returns grades for one semester, including per-course grade options, units, mid-semester and final grades, and QPA summaries. It is distinct from sibling tools like get_schedule or get_advanced_placement by explicitly naming the grading/QPA domain.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives explicit direction: 'Call this when the user asks about grades, QPA/GPA, or units for a semester.' It does not name specific alternatives or state when not to use it, but the context is clear enough for an agent to route correctly.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The readOnlyHint annotation covers safety, and the description adds useful behavioral context beyond it: multiple meeting entries per section, grouping by course_code + section, and defaulting to the current term when term is omitted. It does not explain force_refresh, but that is more a parameter-semantics concern.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Three dense sentences with no filler. The core resource and contents lead, followed by call conditions, then parameter semantics, then the grouping caveat. Every sentence earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the readOnly annotation and the presence of an output schema, the description covers most of what an agent needs: what data is returned, how to request a term, and how to handle multi-meeting sections. The main missing piece is the semantics of force_refresh, which keeps it from being fully complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage, the description must compensate. It does well for `term`, giving accepted formats and default behavior. However, `force_refresh` is never described, leaving its meaning and when to set it unclear. This is a significant gap for one of only two parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly identifies the resource as 'the student's course schedule' and enumerates its contents: meeting days, times, locations, instructors, and deadlines. This makes it easy to distinguish from sibling tools like get_grades or get_enrollment_status, even though get_schedule_ics is not explicitly mentioned.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
It explicitly states when to call: when the user asks about classes, class times, locations, instructors, or their day/week. It does not, however, provide explicit when-not-to-call guidance or direct the agent to an alternative like get_schedule_ics for calendar-file requests.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The annotations already provide readOnlyHint=true, so the description does not need to restate safety. It adds useful behavioral context by specifying the record is semester-scoped and listing returned fields, but it does not disclose behaviors like default term handling, null results, or data availability. Because annotations cover the core safety profile, this is adequate but not rich.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences with no filler. The first sentence front-loads the payload, and the second provides routing guidance. Every sentence contributes information that is not already present in the annotations or schema.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a read-only tool with one optional parameter and an output schema, the description is sufficiently complete: it states what the record contains, how it is scoped, and when to use it. The minor gap around term format/default is low-risk because the parameter is optional and the output schema exists.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema gives no description for the single term parameter (0% coverage). The description adds the semantic clue that the record is 'for a semester,' which helps map term to a semester selector, but it does not explain accepted formats, default behavior, or what null means. This partially compensates for the schema gap but not completely.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description identifies the resource ('Enrollment record for a semester') and enumerates meaningful content: status, units carried vs maximum, class level, degree/college/major, and advisor. It also distinguishes itself from the sibling tool get_student_context by noting it covers details 'beyond what get_student_context gives,' so an agent can tell which tool to use.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
It gives an explicit when-to-use directive: 'Call this for questions about enrollment verification, unit load, or program/major details beyond what get_student_context gives.' This names the alternative tool and sets a clear boundary between general student context and enrollment-specific details.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The annotations already declare readOnlyHint=true, so the description does not need to restate that this is a safe read operation. The description adds useful context that the current semester can be reused as a term argument elsewhere, but it does not disclose edge cases such as missing or stale data. This is sufficient given the annotation coverage.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two concise sentences with no redundant wording. The core purpose and data fields are front-loaded, followed by a clear usage directive. Every sentence earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a no-parameter, read-only tool with an output schema, the description fully covers what data is returned and when to invoke the tool. It also explains how the output can be used in downstream calls, making it complete for correct invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, and the input schema is empty, so there is nothing to document. The description appropriately references 'term' as an output value to be reused, which is helpful context beyond the schema. Baseline 4 applies for zero-parameter tools.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly identifies the tool's purpose: retrieving a current snapshot of the student's academic context, with a concrete list of fields such as name, term, class level, major, and advisor. This specificity distinguishes it from sibling tools like get_schedule and get_grades, which target different academic data.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
It provides strong usage guidance: 'Call this first in any conversation touching academics' and 'whenever you need the current semester to pass as a term argument elsewhere.' However, it does not explicitly discuss when to use sibling tools instead, so it lacks exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Beyond the readOnlyHint annotation, the description discloses meaningful behavior: weekly RRULEs bounded to the semester, local America/New_York wall-clock times, and authority on semester boundaries. These details help the agent anticipate recurrence and timezone behavior without needing to inspect the output. There is no contradiction with the annotation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is compact, front-loaded with the core purpose, and immediately provides usage context and timezone details. Every clause earns its place, with no filler or repetition of schema information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given a single optional parameter and an existing output schema, the description covers purpose, usage routing, recurrence, and timezone. The only notable omission is the meaning of the term parameter, which could matter when targeting a specific semester. Overall, it is quite complete for a low-complexity tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The lone parameter term has 0% schema description coverage, and the description never mentions it or explains how it affects the export. With such low schema coverage, the description should compensate but does not. The agent cannot determine what term values are expected or what the default behavior is.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description names a specific deliverable: the official iCalendar (.ics) export of the schedule. It also differentiates from sibling get_schedule by noting it is authoritative on semester start and end dates and includes weekly RRULEs. The verb 'export' is specific, and the format is clearly identified.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
It explicitly says to call this when integrating with calendar tools or when the user wants schedule as calendar events. It contrasts with get_schedule, which does not carry semester date authority, giving the agent a clear decision rule. This is strong routing guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The readOnlyHint annotation already signals safety, and the description adds meaningful behavioral context: the returned units are not graded and do not affect QPA. This is useful nuance beyond the schema and annotation, though the description does not detail the output structure—mitigated by the presence of an output schema.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is compact and front-loaded. The first line summarizes the content, the second line gives direct usage guidance, and the final line clarifies an important semantic distinction. No fluff.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-parameter, read-only tool with an output schema, the description covers what it returns, when to call it, and how the data behaves (ungraded, no QPA impact). Nothing essential is missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, so the description has no parameter-level burden. The baseline of 4 applies here since no parameter documentation is needed.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states the resource ('AP and transfer credit') and what it returns ('courses credited... and the AP exam scores behind them'). It also differentiates from graded coursework by explicitly noting units are not graded and do not factor into QPA, distinguishing it from the sibling get_grades.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides explicit trigger conditions: 'Call this when the user asks about AP credit, transfer credit, or exam scores.' This gives clear when-to-use guidance and implicitly differentiates it from grade-related tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

GitHub Badge

Glama performs regular codebase and documentation scans to:

Confirm that the MCP server is working as expected.
Confirm that there are no obvious security issues.
Evaluate tool definition quality.

Our badge communicates server capabilities, safety, and installation instructions.

Card Badge

Copy to your README.md:

[![sio-mcp MCP server](https://glama.ai/mcp/servers/noah-lowry/sio-mcp/badges/card.svg)](https://glama.ai/mcp/servers/noah-lowry/sio-mcp)

Score Badge

Copy to your README.md:

[![sio-mcp MCP server](https://glama.ai/mcp/servers/noah-lowry/sio-mcp/badges/score.svg)](https://glama.ai/mcp/servers/noah-lowry/sio-mcp)

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/noah-lowry/sio-mcp'

If you have feedback or need assistance with the MCP directory API, please join our Discord server