Koskamo

ScoreFluent MCP

An official MCP server operated by ScoreFluent that provides English exam preparation tools. It allows agents to retrieve exam overviews, access practice questions, score writing tasks, and link to diagnostic tests for exams like PTE, IELTS, and TOEFL.

Visit ScoreFluent

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.

ScoreFluent MCP logo, by ScoreFluentVendor evidenceStreamable HTTPNo sign-inEndpoint checked 2026-11-07Operated by ScoreFluent
MCP endpoint (Streamable HTTP)
https://api.scorefluent.com/mcp/copilot
Vendor documentation

What its tools do

9 tools, grouped by the hints the server advertises. Hints are self-declared, not verified behavior.

Read-only (6)

Can change data (3)

9 of 9 have a description · 9 of 9 declare behavior hints · 6 of 9 with parameters document them all

Checks and signals

Each line is separate evidence, not a trust score.

  • Passed Endpoint answered the live check ·
  • Passed Official MCP Registry namespace is tied to scorefluent.com ·
  • Passed Endpoint is on the registry namespace domain ·
  • Availability 1 of 1 checks passed in 30 days

What you can do with it

  • Retrieve exam structure and scoring scales
  • Get real practice questions for specific task types
  • Score writing essays based on marking criteria
  • Link to free English diagnostic tests

Source and maintenance

Vendor evidenceRegistry 0.1.0
mcp-registry: com.scorefluent/scorefluent@0.1.0Project website

Protocol and capabilities

Server
scorefluent 0.0.1
MCP protocol negotiated in check
2025-11-25
Tools
9 advertised
Resources
1 advertised
Resource templates
0 advertised
Prompts
Not advertised
Server-advertised capabilities
{
  "tools": {
    "listChanged": true
  },
  "resources": {
    "listChanged": true
  }
}

Tools

9 advertised

exam_overview — Exam overview
Advertised by the server during the last successful anonymous check.
Advertised read-only

Use this when a student asks what an English exam contains, how a task type is scored, how long a section is, what the score scale is, or where to start preparing. Returns the exam sections with task types, question counts and time limits, the writing and speaking scoring criteria (writing with word limits), and links to ScoreFluent guides. Do not use this to score or mark a student's answer; it only describes the exam.

exam_overview input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "exam"
  ],
  "properties": {
    "exam": {
      "enum": [
        "pte",
        "languagecert_academic",
        "toefl",
        "met",
        "celpip",
        "ielts",
        "ielts_general",
        "c1_advanced",
        "pte_core"
      ],
      "type": "string",
      "description": "Exam id, e.g. \"pte\", \"toefl\", \"ielts\", \"languagecert_academic\"."
    },
    "taskType": {
      "type": "string",
      "description": "Optional task-type slug (e.g. \"write-essay\") to narrow the answer to one task."
    }
  }
}
exam_overview output schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "exam",
    "label",
    "scale",
    "sections",
    "writingRubrics",
    "speakingCriteria",
    "links"
  ],
  "properties": {
    "exam": {
      "type": "string"
    },
    "label": {
      "type": "string"
    },
    "links": {
      "type": "object",
      "required": [
        "guides"
      ],
      "properties": {
        "guides": {
          "type": "array",
          "items": {
            "type": "object",
            "required": [
              "taskType",
              "url"
            ],
            "properties": {
              "url": {
                "type": "string"
              },
              "taskType": {
                "type": "string"
              }
            },
            "additionalProperties": false
          }
        },
        "examHub": {
          "type": "string"
        }
      },
      "additionalProperties": false
    },
    "scale": {
      "type": "object",
      "required": [
        "min",
        "max",
        "defaultTarget"
      ],
      "properties": {
        "max": {
          "type": "number"
        },
        "min": {
          "type": "number"
        },
        "step": {
          "type": "number"
        },
        "defaultTarget": {
          "type": "number"
        }
      },
      "additionalProperties": false
    },
    "scoredBy": {
      "enum": [
        "machine",
        "human"
      ],
      "type": "string"
    },
    "sections": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "label",
          "pillar",
          "taskTypes",
          "questionCount",
          "timeLimitSeconds"
        ],
        "properties": {
          "label": {
            "type": "string"
          },
          "pillar": {
            "type": [
              "string",
              "null"
            ]
          },
          "taskTypes": {
            "type": "array",
            "items": {
              "type": "object",
              "required": [
                "slug",
                "label"
              ],
              "properties": {
                "slug": {
                  "type": "string"
                },
                "label": {
                  "type": "string"
                }
              },
              "additionalProperties": false
            }
          },
          "questionCount": {
            "type": "number"
          },
          "timeLimitSeconds": {
            "type": "number"
          }
        },
        "additionalProperties": false
      }
    },
    "writingRubrics": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "taskType",
          "taskLabel",
          "criteria",
          "totalMax",
          "wordMin",
          "wordMax"
        ],
        "properties": {
          "wordMax": {
            "type": "number"
          },
          "wordMin": {
            "type": "number"
          },
          "criteria": {
            "type": "array",
            "items": {
              "type": "object",
              "required": [
                "label",
                "max"
              ],
              "properties": {
                "max": {
                  "type": "number"
                },
                "label": {
                  "type": "string"
                }
              },
              "additionalProperties": false
            }
          },
          "taskType": {
            "type": "string"
          },
          "totalMax": {
            "type": "number"
          },
          "zeroRule": {
            "type": "string"
          },
          "taskLabel": {
            "type": "string"
          }
        },
        "additionalProperties": false
      }
    },
    "speakingCriteria": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "taskType",
          "taskLabel",
          "framing",
          "criteria"
        ],
        "properties": {
          "framing": {
            "enum": [
              "official",
              "practice_estimate"
            ],
            "type": "string"
          },
          "criteria": {
            "type": "array",
            "items": {
              "type": "object",
              "required": [
                "label",
                "max"
              ],
              "properties": {
                "max": {
                  "anyOf": [
                    {
                      "type": "number"
                    },
                    {
                      "type": "string",
                      "const": "reference_words"
                    }
                  ]
                },
                "label": {
                  "type": "string"
                }
              },
              "additionalProperties": false
            }
          },
          "footnote": {
            "type": "string"
          },
          "taskType": {
            "type": "string"
          },
          "taskLabel": {
            "type": "string"
          }
        },
        "additionalProperties": false
      }
    }
  },
  "additionalProperties": false
}
exam_overview annotations
{
  "title": "Exam overview",
  "readOnlyHint": true,
  "openWorldHint": false,
  "destructiveHint": false
}
practice_question — Practice question
Advertised by the server during the last successful anonymous check.
Advertised read-only

Use this when a student wants a real practice question for an English exam task, for example "give me a PTE Write Essay prompt" or "a TOEFL listening question". Returns one random published question (prompt, passage, options, word limit, and an audio link for listening tasks) and a link where the student can answer it with the real timer and scoring. It never returns answers or model responses. Do not use it to check an answer; it only serves questions. For PTE Read Aloud or Describe Image, use speak_practice instead: it serves the question with a recorder so the student can answer and be scored in the chat.

practice_question input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "taskType"
  ],
  "properties": {
    "exam": {
      "enum": [
        "pte",
        "languagecert_academic",
        "toefl",
        "met",
        "celpip",
        "ielts",
        "ielts_general",
        "c1_advanced",
        "pte_core"
      ],
      "type": "string",
      "default": "pte",
      "description": "Exam id. Defaults to \"pte\"."
    },
    "taskType": {
      "type": "string",
      "description": "Task-type slug, e.g. \"write-essay\" or \"listening-mcq-single\". Call exam_overview to list the valid slugs."
    }
  }
}
practice_question output schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "questionId",
    "exam",
    "taskType",
    "taskLabel",
    "pillar",
    "difficulty",
    "estimatedDurationSeconds",
    "question",
    "answerUrl"
  ],
  "properties": {
    "exam": {
      "type": "string"
    },
    "pillar": {
      "type": "string"
    },
    "audioUrl": {
      "type": "string"
    },
    "question": {
      "type": "object",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    },
    "taskType": {
      "type": "string"
    },
    "answerUrl": {
      "type": "string"
    },
    "taskLabel": {
      "type": "string"
    },
    "difficulty": {
      "type": "number"
    },
    "questionId": {
      "type": "string"
    },
    "estimatedDurationSeconds": {
      "type": [
        "number",
        "null"
      ]
    }
  },
  "additionalProperties": false
}
practice_question annotations
{
  "title": "Practice question",
  "readOnlyHint": true,
  "openWorldHint": false,
  "destructiveHint": false
}
score_writing — Score writing
Advertised by the server during the last successful anonymous check.

Use this when a student pastes an essay or summary for a PTE, IELTS, TOEFL, LanguageCert, MET or CELPIP writing task and wants a score. Returns marks out of the exam task maximum, a score and one line of feedback for each marking criterion, and the top improvements. Pass the questionId from practice_question when the text answers one of our questions; otherwise pass the prompt the student wrote to. Pass exactly one of the two. Free up to a daily limit. This is the quick score: Personalised Tips on the site add sentence-level annotations and verified marks. When the student is signed in to ScoreFluent and the text answers one of our questions, the scored attempt is saved to their History.

score_writing input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "exam",
    "taskType",
    "text"
  ],
  "properties": {
    "exam": {
      "enum": [
        "pte",
        "languagecert_academic",
        "toefl",
        "met",
        "celpip",
        "ielts",
        "ielts_general",
        "c1_advanced",
        "pte_core"
      ],
      "type": "string",
      "description": "Exam id, e.g. \"pte\" or \"toefl\"."
    },
    "text": {
      "type": "string",
      "maxLength": 5000,
      "minLength": 20,
      "description": "The student's essay or summary, exactly as they wrote it."
    },
    "prompt": {
      "type": "string",
      "maxLength": 1500,
      "description": "The prompt the student wrote to, when the text does not answer one of our questions."
    },
    "taskType": {
      "type": "string",
      "description": "Writing task-type slug, e.g. \"write-essay\" or \"summarize-written-text\". Call exam_overview to list the valid slugs."
    },
    "questionId": {
      "type": "string",
      "format": "uuid",
      "pattern": "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$",
      "description": "The questionId returned by practice_question, when the text answers one of our questions."
    }
  }
}
score_writing output schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "exam",
    "taskType",
    "wordCount",
    "marks",
    "criteria",
    "overallFeedback",
    "improvements",
    "tier",
    "fullReportUrl"
  ],
  "properties": {
    "exam": {
      "type": "string"
    },
    "tier": {
      "type": "string",
      "const": "shallow"
    },
    "marks": {
      "type": "object",
      "required": [
        "raw",
        "max"
      ],
      "properties": {
        "max": {
          "type": "number"
        },
        "raw": {
          "type": "number"
        }
      },
      "additionalProperties": false
    },
    "criteria": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "key",
          "label",
          "score",
          "max",
          "feedback"
        ],
        "properties": {
          "key": {
            "type": "string"
          },
          "max": {
            "type": "number"
          },
          "label": {
            "type": "string"
          },
          "score": {
            "type": "number"
          },
          "feedback": {
            "type": "string"
          }
        },
        "additionalProperties": false
      }
    },
    "taskType": {
      "type": "string"
    },
    "wordCount": {
      "type": "number"
    },
    "questionId": {
      "type": "string"
    },
    "improvements": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "fullReportUrl": {
      "type": "string"
    },
    "overallFeedback": {
      "type": "string"
    }
  },
  "additionalProperties": false
}
score_writing annotations
{
  "title": "Score writing",
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
start_diagnostic — Start a diagnostic
Advertised by the server during the last successful anonymous check.
Advertised read-only

Use when a student does not know which exam to take (diagnostic) or knows the exam and wants a starting baseline (placement). Returns a link to a free test on the site; do not try to run the test in chat.

start_diagnostic input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "exam": {
      "enum": [
        "pte",
        "languagecert_academic",
        "toefl",
        "met",
        "celpip",
        "ielts",
        "ielts_general",
        "c1_advanced",
        "pte_core"
      ],
      "type": "string",
      "description": "Exam id when the student already knows it, e.g. \"pte\". Omit when they are not sure which exam to take."
    }
  }
}
start_diagnostic output schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "kind",
    "url",
    "minutes",
    "what"
  ],
  "properties": {
    "url": {
      "type": "string"
    },
    "kind": {
      "enum": [
        "placement",
        "diagnostic"
      ],
      "type": "string"
    },
    "what": {
      "type": "string"
    },
    "minutes": {
      "type": "number"
    }
  },
  "additionalProperties": false
}
start_diagnostic annotations
{
  "title": "Start a diagnostic",
  "readOnlyHint": true,
  "openWorldHint": false,
  "destructiveHint": false
}
check_read_aloud — Check a Read Aloud transcript
Advertised by the server during the last successful anonymous check.
Advertised read-only

Use when a student has read a Read Aloud passage aloud and you have the transcript of what they said (for example from voice mode) but no audio. Compares the words said against the passage: omitted, inserted and substituted words and a word-accuracy percentage. CONTENT ONLY — pronunciation, fluency and prosody need a recording: offer speak_practice or the answer link for those.

check_read_aloud input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "questionId",
    "transcript"
  ],
  "properties": {
    "questionId": {
      "type": "string",
      "format": "uuid",
      "pattern": "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$",
      "description": "The questionId returned by speak_practice or practice_question for a Read Aloud passage."
    },
    "transcript": {
      "type": "string",
      "maxLength": 4000,
      "minLength": 1,
      "description": "What the student said, as text."
    }
  }
}
check_read_aloud output schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "questionId",
    "passageWordCount",
    "saidWordCount",
    "matched",
    "accuracy",
    "omitted",
    "inserted",
    "substituted",
    "scope",
    "answerUrl"
  ],
  "properties": {
    "scope": {
      "type": "string",
      "const": "content-only"
    },
    "matched": {
      "type": "number"
    },
    "omitted": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "accuracy": {
      "type": "number"
    },
    "inserted": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "answerUrl": {
      "type": "string"
    },
    "questionId": {
      "type": "string"
    },
    "substituted": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "expected",
          "said"
        ],
        "properties": {
          "said": {
            "type": "string"
          },
          "expected": {
            "type": "string"
          }
        },
        "additionalProperties": false
      }
    },
    "saidWordCount": {
      "type": "number"
    },
    "passageWordCount": {
      "type": "number"
    }
  },
  "additionalProperties": false
}
check_read_aloud annotations
{
  "title": "Check a Read Aloud transcript",
  "readOnlyHint": true,
  "openWorldHint": false,
  "destructiveHint": false
}
speak_practice — Speaking practice
Advertised by the server during the last successful anonymous check.
Advertised read-only

Use whenever a student asks for a PTE Read Aloud or Describe Image to practise, even without mentioning recording or scores. Lets them practise the speaking task and get pronunciation and fluency scores. Shows a recorder card; desktop web only today. Do not use for scoring text.

speak_practice input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "exam": {
      "enum": [
        "pte",
        "languagecert_academic",
        "toefl",
        "met",
        "celpip",
        "ielts",
        "ielts_general",
        "c1_advanced",
        "pte_core"
      ],
      "type": "string",
      "default": "pte",
      "description": "Exam id. Defaults to \"pte\"."
    },
    "taskType": {
      "enum": [
        "read-aloud",
        "describe-image"
      ],
      "type": "string",
      "default": "read-aloud",
      "description": "\"read-aloud\" or \"describe-image\". Defaults to \"read-aloud\"."
    }
  }
}
speak_practice output schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "questionId",
    "exam",
    "taskType",
    "taskLabel",
    "prompt",
    "timeLimitSeconds",
    "answerUrl"
  ],
  "properties": {
    "exam": {
      "type": "string"
    },
    "prompt": {
      "type": "object",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    },
    "taskType": {
      "type": "string"
    },
    "answerUrl": {
      "type": "string"
    },
    "taskLabel": {
      "type": "string"
    },
    "questionId": {
      "type": "string"
    },
    "timeLimitSeconds": {
      "type": "number"
    }
  },
  "additionalProperties": false
}
speak_practice annotations
{
  "title": "Speaking practice",
  "readOnlyHint": true,
  "openWorldHint": false,
  "destructiveHint": false
}
recorder_start — Start a recording
Advertised by the server during the last successful anonymous check.

Reserve a recording slot and get an upload URL. Called by the speaking recorder card only.

recorder_start input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "deviceToken",
    "questionId",
    "mimeType"
  ],
  "properties": {
    "mimeType": {
      "enum": [
        "audio/webm",
        "audio/mp4",
        "audio/m4a",
        "audio/aac"
      ],
      "type": "string"
    },
    "questionId": {
      "type": "string",
      "format": "uuid",
      "pattern": "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$"
    },
    "deviceToken": {
      "type": "string",
      "format": "uuid",
      "pattern": "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$"
    }
  }
}
recorder_start output schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "attemptId",
    "uploadUrl",
    "expiresInSeconds"
  ],
  "properties": {
    "attemptId": {
      "type": "string"
    },
    "uploadUrl": {
      "type": "string"
    },
    "expiresInSeconds": {
      "type": "number"
    }
  },
  "additionalProperties": false
}
recorder_start annotations
{
  "title": "Start a recording",
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
recorder_confirm — Submit a recording
Advertised by the server during the last successful anonymous check.

Confirm the upload and queue it for scoring. Called by the speaking recorder card only.

recorder_confirm input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "attemptId",
    "deviceToken"
  ],
  "properties": {
    "attemptId": {
      "type": "string",
      "format": "uuid",
      "pattern": "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$"
    },
    "deviceToken": {
      "type": "string",
      "format": "uuid",
      "pattern": "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$"
    }
  }
}
recorder_confirm output schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "ok"
  ],
  "properties": {
    "ok": {
      "type": "boolean",
      "const": true
    }
  },
  "additionalProperties": false
}
recorder_confirm annotations
{
  "title": "Submit a recording",
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
recorder_result — Recording result
Advertised by the server during the last successful anonymous check.
Advertised read-only

Read the scoring status and scores for a recording. Called by the speaking recorder card only.

recorder_result input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "attemptId",
    "deviceToken"
  ],
  "properties": {
    "attemptId": {
      "type": "string",
      "format": "uuid",
      "pattern": "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$"
    },
    "deviceToken": {
      "type": "string",
      "format": "uuid",
      "pattern": "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$"
    }
  }
}
recorder_result output schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "status",
    "fullReportUrl"
  ],
  "properties": {
    "scores": {
      "type": "object",
      "required": [
        "overall",
        "accuracy",
        "fluency",
        "prosody",
        "completeness"
      ],
      "properties": {
        "fluency": {
          "type": [
            "number",
            "null"
          ]
        },
        "overall": {
          "type": "number"
        },
        "prosody": {
          "type": [
            "number",
            "null"
          ]
        },
        "accuracy": {
          "type": [
            "number",
            "null"
          ]
        },
        "completeness": {
          "type": [
            "number",
            "null"
          ]
        }
      },
      "additionalProperties": false
    },
    "status": {
      "type": "string"
    },
    "transcript": {
      "type": "string"
    },
    "fullReportUrl": {
      "type": "string"
    }
  },
  "additionalProperties": false
}
recorder_result annotations
{
  "title": "Recording result",
  "readOnlyHint": true,
  "openWorldHint": false,
  "destructiveHint": false
}

Prompts

Not advertised

No prompt definitions available.

Resources

1 advertised

recorder — Speaking recorder

Advertised by the server during the last successful anonymous check.

recorder URI
ui://scorefluent/recorder

MIME type: text/html;profile=mcp-app

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
2167 ms
95th percentile latency
2167 ms

Maintenance history

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

  • · probe · passed · 2167 ms · metadata changed · 9 tool(s), 1 resource(s), 0 resource template(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 scorefluent-mcp https://api.scorefluent.com/mcp/copilot

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 scorefluent-mcp --url https://api.scorefluent.com/mcp/copilot

Cursor

Merge this server into .cursor/mcp.json in your project, then enable scorefluent-mcp in your MCP settings.
Cursor configuration
{
  "mcpServers": {
    "scorefluent-mcp": {
      "url": "https://api.scorefluent.com/mcp/copilot"
    }
  }
}

Cline

Merge this into cline_mcp_settings.json (Cline → MCP Servers → Configure).
Cline configuration
{
  "mcpServers": {
    "scorefluent-mcp": {
      "type": "streamableHttp",
      "url": "https://api.scorefluent.com/mcp/copilot",
      "disabled": false
    }
  }
}

VS Code

Merge this server into .vscode/mcp.json. Use MCP: List Servers to start scorefluent-mcp and inspect its tools.
VS Code configuration
{
  "servers": {
    "scorefluent-mcp": {
      "type": "http",
      "url": "https://api.scorefluent.com/mcp/copilot"
    }
  }
}

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 scorefluent-mcp https://api.scorefluent.com/mcp/copilot

Claude Desktop

Open Claude Settings > Connectors > Add custom connector, enter this server URL and enable it for the conversation. This is a manual remote-connector handoff, not a desktop JSON configuration.
Claude Desktop configuration
https://api.scorefluent.com/mcp/copilot

Windsurf

Merge this into ~/.codeium/windsurf/mcp_config.json, then refresh MCP in Cascade. Windsurf remote servers use serverUrl, not url.
Windsurf configuration
{
  "mcpServers": {
    "scorefluent-mcp": {
      "serverUrl": "https://api.scorefluent.com/mcp/copilot"
    }
  }
}

Let your agent find its tools

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

Connect Koskamo Explore workflows
See all 5,895

Do you run ScoreFluent 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