Koskamo

Calculator for Grading MCP

A public MCP server providing read-only tools for calculating grades from questions wrong, final exam scores needed, weighted averages, GPA, SAT/ACT/MCAT practice scores, and grading scale facts. It requires no authentication, stores no personal data, and returns results with links to the corresponding calculators on the website.

Endpoint and access

No sign-in to connect and list tools. Individual tools may still need a vendor account, credentials, or permissions; check the documented prerequisites.

Calculator for Grading MCP logo, by Calculator for GradingVendor evidenceStreamable HTTPNo sign-inEndpoint checked 2026-11-01Operated by Calculator for Grading
MCP endpoint (Streamable HTTP)
https://calculatorforgrading.com/mcp?src=mcp
Vendor documentation

What you can do with it

  • Calculate grade percentage from total questions and wrong answers
  • Determine the score needed on a final exam to reach a target grade
  • Compute weighted averages for course categories
  • Estimate GPA from course grades or SAT/ACT/MCAT practice scores

Source and maintenance

Vendor evidenceRegistry 1.1.0

Protocol and capabilities

Server
calculatorforgrading 1.1.0
MCP protocol
2025-06-18
Tools
6 advertised
Resources
Not advertised
Resource templates
Not advertised
Prompts
Not advertised
Server-advertised capabilities
{
  "tools": {
    "listChanged": false
  }
}

Server-provided instructions

Untrusted server output shown for inspection. It is not Koskamo guidance and is excluded from knowledge search.

Grade, GPA and test-score arithmetic from calculatorforgrading.com. Use the tools for every number: percent and letter from questions wrong, score needed on a final, weighted average, GPA, SAT/ACT/MCAT practice-test scores, and grading-scale tables with sources. Never ask for names, student IDs or school names; only numbers and letters are needed. Letter cut-offs differ by school: say which scale was used and tell the user to check their syllabus. Results are estimates for practice and planning, not official grades or scores. Answer in the user's language, keep the one-line method, and keep the link line at the end of the answer.

Tools

6 advertised

grade_calculator — Grade from questions wrong
Advertised by the server during the last successful anonymous check.
Advertised read-only

Use this when a student or teacher wants the percent and letter grade for a test from the number of questions wrong (or correct), e.g. "7 wrong out of 40". Returns the percent, the letter on the chosen scale, how many more correct answers reach the next letter, and optionally a chart of every possible number wrong. Do not use it for a final-exam target, weighted categories, GPA or test scores. Needs only numbers; never ask for names.

grade_calculator input schema
{
  "type": "object",
  "required": [
    "total_questions"
  ],
  "properties": {
    "scale": {
      "enum": [
        "10_point",
        "7_point",
        "plus_minus",
        "pass_fail"
      ],
      "type": "string",
      "description": "10_point = A 90, B 80, C 70, D 60 (default); 7_point = A 93, B 85, C 77, D 70; plus_minus = the site's preset with A+ 97 ... D- 60; pass_fail = pass at 60."
    },
    "wrong": {
      "type": "integer",
      "minimum": 0,
      "description": "Questions wrong. Give wrong or correct, not both."
    },
    "correct": {
      "type": "integer",
      "minimum": 0,
      "description": "Questions correct. Give wrong or correct, not both."
    },
    "decimals": {
      "enum": [
        0,
        1,
        2
      ],
      "type": "integer",
      "description": "Decimals shown in the percent (default 0)."
    },
    "rounding": {
      "enum": [
        "nearest",
        "down"
      ],
      "type": "string",
      "description": "nearest rounds half up (default); down never rounds up, for teachers who truncate."
    },
    "include_chart": {
      "type": "boolean",
      "description": "Also return a chart row for each possible number wrong (first 60 rows)."
    },
    "custom_cutoffs": {
      "type": "array",
      "items": {
        "type": "number"
      },
      "description": "Optional own cut-off percents, highest grade first, strictly descending (10_point: A, B, C, D = 4 numbers; plus_minus: 12 numbers). Use only when the user gives them."
    },
    "total_questions": {
      "type": "integer",
      "maximum": 10000,
      "minimum": 1,
      "description": "Number of questions or points on the test."
    }
  },
  "additionalProperties": false
}
grade_calculator output schema
{
  "type": "object",
  "required": [
    "total_questions",
    "wrong",
    "correct",
    "percent_exact",
    "percent_shown",
    "letter",
    "scale",
    "rule",
    "next_letter",
    "link"
  ],
  "properties": {
    "link": {
      "type": "string",
      "description": "Page of calculatorforgrading.com with the same inputs filled in."
    },
    "rule": {
      "type": "string"
    },
    "chart": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "wrong",
          "correct",
          "percent",
          "letter"
        ],
        "properties": {
          "wrong": {
            "type": "number"
          },
          "letter": {
            "type": "string"
          },
          "correct": {
            "type": "number"
          },
          "percent": {
            "type": "string"
          }
        },
        "additionalProperties": false
      }
    },
    "scale": {
      "type": "string"
    },
    "wrong": {
      "type": "integer"
    },
    "letter": {
      "type": "string"
    },
    "correct": {
      "type": "integer"
    },
    "next_letter": {
      "anyOf": [
        {
          "type": "object",
          "required": [
            "letter",
            "min_percent",
            "more_correct_needed",
            "percent_then"
          ],
          "properties": {
            "letter": {
              "type": "string"
            },
            "min_percent": {
              "type": "number"
            },
            "percent_then": {
              "type": "number"
            },
            "more_correct_needed": {
              "type": "integer"
            }
          },
          "additionalProperties": false
        },
        {
          "type": "null"
        }
      ]
    },
    "percent_exact": {
      "type": "number"
    },
    "percent_shown": {
      "type": "number"
    },
    "total_questions": {
      "type": "integer"
    }
  },
  "additionalProperties": false
}
grade_calculator annotations
{
  "title": "Grade from questions wrong",
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
final_grade_needed — Score needed on the final
Advertised by the server during the last successful anonymous check.
Advertised read-only

Use this when a student asks what score they need on a final exam (or last assignment) to reach a target grade, given the current grade and how much the final counts. Returns the needed percent, whether it is secured or out of reach, what a 0 and a 100 would leave, and the need for every letter. Works with percents (current_grade_percent + final_weight_percent) or with points (points_earned_so_far, points_possible_so_far, final_exam_points). Do not use it for a weighted average of categories.

final_grade_needed input schema
{
  "type": "object",
  "required": [
    "target_grade"
  ],
  "properties": {
    "scale": {
      "enum": [
        "10_point",
        "plus_minus"
      ],
      "type": "string",
      "description": "10_point (default) or plus_minus, used to read a letter target."
    },
    "target_grade": {
      "type": [
        "string",
        "number"
      ],
      "description": "Wanted grade: a percent (90) or a letter (B+)."
    },
    "final_exam_points": {
      "type": "number",
      "description": "Points mode: points the final is worth."
    },
    "final_weight_percent": {
      "type": "number",
      "maximum": 100,
      "minimum": 0.01,
      "description": "How much of the course grade the final counts, in percent."
    },
    "points_earned_so_far": {
      "type": "number",
      "description": "Points mode: points earned so far."
    },
    "current_grade_percent": {
      "type": "number",
      "maximum": 150,
      "minimum": 0,
      "description": "Current course grade in percent before the final."
    },
    "points_possible_so_far": {
      "type": "number",
      "description": "Points mode: points possible so far."
    }
  },
  "additionalProperties": false
}
final_grade_needed output schema
{
  "type": "object",
  "required": [
    "scale",
    "target",
    "target_percent",
    "verdict",
    "needed_on_final_percent",
    "final_counts_percent",
    "zero_on_final_gives_percent",
    "zero_on_final_letter",
    "hundred_on_final_gives_percent",
    "hundred_on_final_letter",
    "letters",
    "link"
  ],
  "properties": {
    "link": {
      "type": "string",
      "description": "Page of calculatorforgrading.com with the same inputs filled in."
    },
    "scale": {
      "type": "string"
    },
    "target": {
      "type": "string"
    },
    "letters": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "letter",
          "needs_percent",
          "verdict"
        ],
        "properties": {
          "letter": {
            "type": "string"
          },
          "verdict": {
            "type": "string"
          },
          "needs_percent": {
            "type": [
              "number",
              "null"
            ]
          }
        },
        "additionalProperties": false
      }
    },
    "verdict": {
      "enum": [
        "secured",
        "reach",
        "impossible"
      ],
      "type": "string"
    },
    "target_percent": {
      "type": "number"
    },
    "final_counts_percent": {
      "type": "number"
    },
    "zero_on_final_letter": {
      "type": "string"
    },
    "hundred_on_final_letter": {
      "type": "string"
    },
    "needed_on_final_percent": {
      "type": [
        "number",
        "null"
      ]
    },
    "zero_on_final_gives_percent": {
      "type": "number"
    },
    "hundred_on_final_gives_percent": {
      "type": "number"
    }
  },
  "additionalProperties": false
}
final_grade_needed annotations
{
  "title": "Score needed on the final",
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
weighted_grade — Weighted average of categories
Advertised by the server during the last successful anonymous check.
Advertised read-only

Use this when a student wants the weighted course grade from categories such as homework 20%, tests 50%, final 30%. Each row has a score (percent, a fraction like 45/50, or a letter) and a weight; rows without a score count as still open. Returns the weighted average, the letter, how much weight is graded and open, and optionally what the open part must average to reach a target grade. Do not use it for a single final-exam question without categories.

weighted_grade input schema
{
  "type": "object",
  "required": [
    "rows"
  ],
  "properties": {
    "rows": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "weight"
        ],
        "properties": {
          "name": {
            "type": "string",
            "maxLength": 40,
            "description": "Optional category label such as Homework. Never a person's name."
          },
          "score": {
            "type": [
              "number",
              "string"
            ],
            "description": "Percent (92), fraction (45/50) or letter (B+). Leave out for a category not graded yet."
          },
          "weight": {
            "type": "number",
            "maximum": 1000,
            "minimum": 0,
            "description": "Weight of the category (usually percent of the course)."
          }
        },
        "additionalProperties": false
      },
      "maxItems": 30,
      "minItems": 1
    },
    "scale": {
      "enum": [
        "10_point",
        "plus_minus"
      ],
      "type": "string",
      "description": "10_point (default) or plus_minus."
    },
    "target_grade": {
      "type": [
        "string",
        "number"
      ],
      "description": "Optional wanted course grade (percent or letter)."
    }
  },
  "additionalProperties": false
}
weighted_grade output schema
{
  "type": "object",
  "required": [
    "scale",
    "weighted_average_percent",
    "letter",
    "graded_weight_percent",
    "open_weight_percent",
    "note",
    "link"
  ],
  "properties": {
    "link": {
      "type": "string",
      "description": "Page of calculatorforgrading.com with the same inputs filled in."
    },
    "note": {
      "enum": [
        "none",
        "over",
        "under",
        "plain"
      ],
      "type": "string"
    },
    "scale": {
      "type": "string"
    },
    "letter": {
      "type": "string"
    },
    "verdict": {
      "enum": [
        "secured",
        "reach",
        "impossible"
      ],
      "type": "string"
    },
    "target_percent": {
      "type": "number"
    },
    "open_weight_percent": {
      "type": "number"
    },
    "graded_weight_percent": {
      "type": "number"
    },
    "weighted_average_percent": {
      "type": "number"
    },
    "needed_on_remaining_percent": {
      "type": [
        "number",
        "null"
      ]
    }
  },
  "additionalProperties": false
}
weighted_grade annotations
{
  "title": "Weighted average of categories",
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
gpa_calculator — GPA from course grades
Advertised by the server during the last successful anonymous check.
Advertised read-only

Use this when a student wants their GPA from letter grades and credits, high school (honors +0.5, AP/IB +1.0 on passing grades, weighted and unweighted) or college (credit hours, unweighted). Returns unweighted and weighted GPA with the points of each course. Credits default to 1 (hs) or 3 (college). Do not use it for a single test grade or for a school-specific formula such as UC or LSAC.

gpa_calculator input schema
{
  "type": "object",
  "required": [
    "courses"
  ],
  "properties": {
    "mode": {
      "enum": [
        "hs",
        "college"
      ],
      "type": "string",
      "description": "hs = high school with weighting (default); college = unweighted."
    },
    "scale": {
      "enum": [
        "4.0",
        "4.3"
      ],
      "type": "string",
      "description": "4.0 (A+ counts 4.0, default) or 4.3 (A+ counts 4.3)."
    },
    "courses": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "letter"
        ],
        "properties": {
          "level": {
            "enum": [
              "regular",
              "honors",
              "ap"
            ],
            "type": "string",
            "description": "regular (default), honors or ap (AP/IB)."
          },
          "letter": {
            "enum": [
              "A+",
              "A",
              "A-",
              "B+",
              "B",
              "B-",
              "C+",
              "C",
              "C-",
              "D+",
              "D",
              "D-",
              "F"
            ],
            "type": "string",
            "description": "Letter grade."
          },
          "credits": {
            "type": "number",
            "maximum": 30,
            "description": "Credits or credit hours.",
            "exclusiveMinimum": 0
          }
        },
        "additionalProperties": false
      },
      "maxItems": 40,
      "minItems": 1
    }
  },
  "additionalProperties": false
}
gpa_calculator output schema
{
  "type": "object",
  "required": [
    "mode",
    "scale",
    "credits",
    "gpa_unweighted",
    "gpa_weighted",
    "courses",
    "link"
  ],
  "properties": {
    "link": {
      "type": "string",
      "description": "Page of calculatorforgrading.com with the same inputs filled in."
    },
    "mode": {
      "type": "string"
    },
    "scale": {
      "type": "string"
    },
    "courses": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "letter",
          "credits",
          "level",
          "points_unweighted",
          "points_weighted"
        ],
        "properties": {
          "level": {
            "type": "string"
          },
          "letter": {
            "type": "string"
          },
          "credits": {
            "type": "number"
          },
          "points_weighted": {
            "type": [
              "number",
              "null"
            ]
          },
          "points_unweighted": {
            "type": "number"
          }
        },
        "additionalProperties": false
      }
    },
    "credits": {
      "type": "number"
    },
    "gpa_weighted": {
      "type": [
        "number",
        "null"
      ]
    },
    "gpa_unweighted": {
      "type": "number"
    }
  },
  "additionalProperties": false
}
gpa_calculator annotations
{
  "title": "GPA from course grades",
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
test_score_calculator — SAT, ACT and MCAT practice scores
Advertised by the server during the last successful anonymous check.
Advertised read-only

Use this when a student wants a score from a published practice test: SAT (College Board digital practice tests 4-11, correct answers per section to score ranges), ACT (practice tests 1-4 and the National test, correct answers per section to scale scores and Composite) or MCAT (four section scores 118-132 to total and AAMC percentile). Returns the score with the source table and fetch date. Not for official score reports, other tests, or predicting a real exam.

test_score_calculator input schema
{
  "type": "object",
  "required": [
    "test"
  ],
  "properties": {
    "test": {
      "enum": [
        "sat",
        "act",
        "mcat"
      ],
      "type": "string"
    },
    "mcat_cars": {
      "type": "integer",
      "maximum": 132,
      "minimum": 118
    },
    "practice_test": {
      "type": [
        "integer",
        "string"
      ],
      "description": "SAT: practice test number 4-11. ACT: 1, 2, 3, 4 or national."
    },
    "mcat_chem_phys": {
      "type": "integer",
      "maximum": 132,
      "minimum": 118
    },
    "mcat_psych_soc": {
      "type": "integer",
      "maximum": 132,
      "minimum": 118
    },
    "act_math_correct": {
      "type": "integer",
      "maximum": 41,
      "minimum": 0
    },
    "mcat_bio_biochem": {
      "type": "integer",
      "maximum": 132,
      "minimum": 118
    },
    "sat_math_correct": {
      "type": "integer",
      "maximum": 54,
      "minimum": 0,
      "description": "SAT: correct answers in Math (both modules)."
    },
    "act_english_correct": {
      "type": "integer",
      "maximum": 40,
      "minimum": 0
    },
    "act_reading_correct": {
      "type": "integer",
      "maximum": 27,
      "minimum": 0
    },
    "act_science_correct": {
      "type": "integer",
      "maximum": 34,
      "minimum": 0
    },
    "sat_reading_writing_correct": {
      "type": "integer",
      "maximum": 66,
      "minimum": 0,
      "description": "SAT: correct answers in Reading and Writing (both modules)."
    }
  },
  "additionalProperties": false
}
test_score_calculator output schema
{
  "type": "object",
  "required": [
    "test",
    "sections",
    "source",
    "caveat",
    "link"
  ],
  "properties": {
    "link": {
      "type": "string",
      "description": "Page of calculatorforgrading.com with the same inputs filled in."
    },
    "test": {
      "type": "string"
    },
    "total": {
      "type": [
        "number",
        "null"
      ]
    },
    "caveat": {
      "type": "string"
    },
    "source": {
      "type": "object",
      "required": [
        "name",
        "url",
        "fetched"
      ],
      "properties": {
        "url": {
          "type": "string"
        },
        "name": {
          "type": "string"
        },
        "fetched": {
          "type": "string"
        }
      },
      "additionalProperties": false
    },
    "sections": {
      "type": "object",
      "description": "Per-section result; keys depend on the test."
    },
    "composite": {
      "type": [
        "number",
        "null"
      ]
    },
    "total_low": {
      "type": "integer"
    },
    "total_high": {
      "type": "integer"
    },
    "practice_test": {
      "type": "string"
    },
    "percentile_valid": {
      "type": "string"
    },
    "total_percentile": {
      "type": [
        "string",
        "null"
      ]
    }
  },
  "additionalProperties": false
}
test_score_calculator annotations
{
  "title": "SAT, ACT and MCAT practice scores",
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
grading_scale_facts — Grading scale cut-offs with sources
Advertised by the server during the last successful anonymous check.
Advertised read-only

Use this when someone asks what a grading scale is: the 10-point scale (A 90-100), the 7-point scale (A 93-100), the plus-minus scale with GPA points on 4.0 and 4.3, or the College Board percent-to-GPA table. Returns the cut-offs, the named sources and the date they were checked. Use it instead of answering from memory; there is no national scale and schools differ.

grading_scale_facts input schema
{
  "type": "object",
  "required": [
    "scale"
  ],
  "properties": {
    "scale": {
      "enum": [
        "10_point",
        "7_point",
        "plus_minus",
        "college_board"
      ],
      "type": "string"
    }
  },
  "additionalProperties": false
}
grading_scale_facts output schema
{
  "type": "object",
  "required": [
    "scale",
    "title",
    "rows",
    "note",
    "sources",
    "checked",
    "link"
  ],
  "properties": {
    "link": {
      "type": "string",
      "description": "Page of calculatorforgrading.com with the same inputs filled in."
    },
    "note": {
      "type": "string"
    },
    "rows": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "letter",
          "percent"
        ],
        "properties": {
          "letter": {
            "type": "string"
          },
          "gpa_4_0": {
            "type": [
              "number",
              "null"
            ]
          },
          "gpa_4_3": {
            "type": [
              "number",
              "null"
            ]
          },
          "percent": {
            "type": "string"
          }
        }
      }
    },
    "scale": {
      "type": "string"
    },
    "title": {
      "type": "string"
    },
    "checked": {
      "type": "string"
    },
    "sources": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "id",
          "name",
          "url"
        ],
        "properties": {
          "id": {
            "type": "string"
          },
          "url": {
            "type": "string"
          },
          "name": {
            "type": "string"
          }
        },
        "additionalProperties": false
      }
    }
  },
  "additionalProperties": false
}
grading_scale_facts annotations
{
  "title": "Grading scale cut-offs with sources",
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}

Prompts

Not advertised

No prompt definitions available.

Resources

Not advertised

No resource definitions available.

30-day availability

Aggregated from read-only remote checks; this is not a tool-execution or security guarantee.

Successful checks
1 of 1 (100%)
Average latency
386 ms
95th percentile latency
386 ms

Maintenance history

Public check and source-refresh events. Editorial and ownership records remain private.

  • · probe · passed · 386 ms · metadata changed · 6 tool(s)

Connect from your client

Each snippet registers the same endpoint; pick the client you use.

This server is operated by the named third party. Listing and endpoint checks are not an endorsement or a security audit. Review the operator's permissions, terms, and data handling before connecting. How listings are checked and corrected.

Claude Code

Run this once in a terminal. It registers the remote server. Use --scope project to write .mcp.json for the repo.
Claude Code configuration
claude mcp add --transport http calculator-for-grading-mcp https://calculatorforgrading.com/mcp?src=mcp

Codex

Run this once. Codex stores MCP servers in ~/.codex/config.toml (or .codex/config.toml in a trusted project).
Codex configuration
codex mcp add calculator-for-grading-mcp --url https://calculatorforgrading.com/mcp?src=mcp

Cursor

Merge this server into .cursor/mcp.json in your project, then enable calculator-for-grading-mcp in your MCP settings.
Cursor configuration
{
  "mcpServers": {
    "calculator-for-grading-mcp": {
      "url": "https://calculatorforgrading.com/mcp?src=mcp"
    }
  }
}

Cline

Merge this into cline_mcp_settings.json (Cline → MCP Servers → Configure).
Cline configuration
{
  "mcpServers": {
    "calculator-for-grading-mcp": {
      "type": "streamableHttp",
      "url": "https://calculatorforgrading.com/mcp?src=mcp",
      "disabled": false
    }
  }
}

VS Code

Merge this server into .vscode/mcp.json. Use MCP: List Servers to start calculator-for-grading-mcp and inspect its tools.
VS Code configuration
{
  "servers": {
    "calculator-for-grading-mcp": {
      "type": "http",
      "url": "https://calculatorforgrading.com/mcp?src=mcp"
    }
  }
}

Gemini CLI

Run this once. It writes .gemini/settings.json in the current project; pass --scope user for ~/.gemini/settings.json.
Gemini CLI configuration
gemini mcp add --transport http calculator-for-grading-mcp https://calculatorforgrading.com/mcp?src=mcp

Claude Desktop

Merge this into claude_desktop_config.json (macOS: ~/Library/Application Support/Claude/, Windows: %APPDATA%\Claude\), then restart Claude Desktop.
Claude Desktop configuration
{
  "mcpServers": {
    "calculator-for-grading-mcp": {
      "url": "https://calculatorforgrading.com/mcp?src=mcp"
    }
  }
}

Windsurf

Merge this into ~/.codeium/windsurf/mcp_config.json, then refresh MCP in Cascade. Windsurf remote servers use serverUrl, not url.
Windsurf configuration
{
  "mcpServers": {
    "calculator-for-grading-mcp": {
      "serverUrl": "https://calculatorforgrading.com/mcp?src=mcp"
    }
  }
}

Let your agent find its tools

Find servers like Calculator for Grading MCP from your agent. Add Koskamo once to search the index for endpoints, access requirements, and client setup. Public discovery needs no key.

Do you run Calculator for Grading MCP?

Prove ownership with a DNS record, a well-known file, or your Official MCP Registry entry, and your edits publish immediately. Proofs are re-checked weekly; admins can still hide or remove a listing.

Claim this listing