Koskamo

HumMatch MCP

An official MCP server for HumMatch that allows agents to match singers to songs based on vocal range. It provides tools to recommend songs, search the catalog, check specific song fit, perform group matching via SquadMatch, and retrieve a user's vocal profile.

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.

HumMatch MCP logo, by HumMatchVendor evidenceStreamable HTTPNo sign-inEndpoint checked 2026-11-06Operated by HumMatch
MCP endpoint (Streamable HTTP)
https://hummatch.me/api/mcp
Vendor documentation

What its tools do

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

5 of 5 have a description · 5 of 5 declare behavior hints · 5 of 5 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 hummatch.me ·
  • Passed Endpoint is on the registry namespace domain ·
  • Warning Advertises resources/templates/list but does not implement it
  • Availability 1 of 1 checks passed in 30 days

What you can do with it

  • Recommend songs based on a user's vocal range
  • Search the song database for specific criteria
  • Check if a specific song fits a singer's range
  • Match songs for a group using SquadMatch

Source and maintenance

Vendor evidenceRegistry 1.0.0
Maintenance checked

Protocol and capabilities

Server
hummatch 1.0.0
MCP protocol negotiated in check
2025-11-25
Tools
5 advertised
Resources
1 advertised
Resource templates
Not advertised
Prompts
Not advertised
Server-advertised capabilities
{
  "tools": {
    "listChanged": false
  },
  "resources": {
    "subscribe": false,
    "listChanged": false
  }
}

Server-provided instructions

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

HumMatch matches singers to songs by vocal range. Start with the singer's lowest and highest comfortable notes. Use recommend_songs to find what suits one voice, group_song_fit for two or more singers, search_songs to look up a specific song, and check_song_fit to score one song for a voice. Every song carries rangeConfidence and rangeSource: a range marked estimated is derived from published sources rather than measured from the recording, so present those scores as guidance rather than fact.

Tools

5 advertised

get_vocal_profile — Build a vocal profile
Advertised by the server during the last successful anonymous check.
Advertised read-only

Turn a singer's vocal range into a normalized HumMatch vocal profile: a persistent Vocal ID, voice type, and tone label. Call this first when you know someone's range and want a profile to reuse across the other HumMatch tools.

get_vocal_profile input schema
{
  "type": "object",
  "required": [
    "rangeLow",
    "rangeHigh"
  ],
  "properties": {
    "rangeLow": {
      "type": "string",
      "description": "Lowest comfortable note, as a note name like \"D3\" or a raw MIDI number."
    },
    "rangeHigh": {
      "type": "string",
      "description": "Highest comfortable note, as a note name like \"C5\" or a raw MIDI number."
    },
    "voiceType": {
      "type": "string",
      "description": "Optional voice type hint (soprano, mezzo, alto, tenor, baritone, bass). Inferred from the range when omitted."
    }
  },
  "additionalProperties": false
}
get_vocal_profile output schema
{
  "type": "object",
  "required": [
    "vocalId",
    "rangeLow",
    "rangeHigh",
    "voiceType"
  ],
  "properties": {
    "vocalId": {
      "type": "string",
      "description": "Human-readable profile label, e.g. \"Tenor - Balanced tone\"."
    },
    "rangeLow": {
      "type": "integer",
      "description": "Lowest comfortable note as MIDI."
    },
    "rangeHigh": {
      "type": "integer",
      "description": "Highest comfortable note as MIDI."
    },
    "toneLabel": {
      "type": "string"
    },
    "voiceType": {
      "type": "string"
    },
    "humProfile": {
      "type": "object",
      "properties": {
        "low": {
          "type": "integer"
        },
        "high": {
          "type": "integer"
        },
        "center": {
          "type": "integer"
        },
        "confidence": {
          "type": "number",
          "description": "0-1. Derived from range input alone is around 0.55."
        },
        "timbreLabel": {
          "type": "string"
        },
        "warmthScore": {
          "type": [
            "number",
            "null"
          ]
        },
        "pitchStability": {
          "type": "number"
        },
        "brightnessScore": {
          "type": [
            "number",
            "null"
          ]
        },
        "timbreConfidence": {
          "type": "number"
        }
      },
      "description": "Underlying measurements. Timbre fields stay null until an actual hum recording has been analyzed."
    }
  }
}
get_vocal_profile annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
recommend_songs — Find songs that fit a voice
Advertised by the server during the last successful anonymous check.
Advertised read-only

Rank the HumMatch catalog for one singer and return the songs they can actually sing, scored for range fit, karaoke difficulty, and voice-type suitability. Call this when someone asks what they should sing, what suits their voice or range, or wants karaoke song suggestions. Returns a ranked list plus named buckets (safest picks, easy wins, crowd pleasers, songs to avoid).

recommend_songs input schema
{
  "type": "object",
  "required": [
    "rangeLow",
    "rangeHigh"
  ],
  "properties": {
    "limit": {
      "type": "integer",
      "description": "How many songs to return per bucket (default 12, max 50)."
    },
    "rangeLow": {
      "type": "string",
      "description": "Lowest comfortable note, as a note name like \"D3\" or a raw MIDI number."
    },
    "rangeHigh": {
      "type": "string",
      "description": "Highest comfortable note, as a note name like \"C5\" or a raw MIDI number."
    },
    "voiceType": {
      "type": "string",
      "description": "Optional voice type hint (soprano, mezzo, alto, tenor, baritone, bass). Inferred from the range when omitted."
    }
  },
  "additionalProperties": false
}
recommend_songs output schema
{
  "type": "object",
  "required": [
    "vocalId",
    "voiceType",
    "matches"
  ],
  "properties": {
    "matches": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "slug",
          "title",
          "artist",
          "rangeConfidence"
        ],
        "properties": {
          "url": {
            "type": "string",
            "description": "Canonical HumMatch page for the song."
          },
          "slug": {
            "type": "string",
            "description": "Catalog slug; the identifier check_song_fit takes."
          },
          "year": {
            "type": [
              "integer",
              "null"
            ]
          },
          "genre": {
            "type": "string"
          },
          "title": {
            "type": "string"
          },
          "artist": {
            "type": "string"
          },
          "lowNote": {
            "type": [
              "integer",
              "null"
            ],
            "description": "Lowest note of the song as a MIDI number."
          },
          "highNote": {
            "type": [
              "integer",
              "null"
            ],
            "description": "Highest note of the song as a MIDI number."
          },
          "whyItFits": {
            "type": "string"
          },
          "matchScore": {
            "type": "integer",
            "description": "Overall suitability for this voice, 0-100."
          },
          "lowNoteName": {
            "type": "string",
            "description": "Same as lowNote, as a note name like \"G2\"."
          },
          "rangeSource": {
            "type": "string",
            "description": "Provenance tag for the range, e.g. \"estimated_curated_seed\"."
          },
          "riskWarning": {
            "type": "string"
          },
          "highNoteName": {
            "type": "string",
            "description": "Same as highNote, as a note name like \"C#5\"."
          },
          "suggestedKey": {
            "type": "string",
            "description": "Transposition advice, e.g. \"Try a lower key\"."
          },
          "vocalFitScore": {
            "type": "integer",
            "description": "How well the song range sits inside the singer range, 0-100."
          },
          "likelyVoiceFit": {
            "type": "string"
          },
          "tessituraScore": {
            "type": "integer",
            "description": "How comfortable the song sits where the voice spends most time, 0-100."
          },
          "difficultyScore": {
            "type": [
              "integer",
              "null"
            ],
            "description": "Karaoke difficulty, 0-100. Higher is harder."
          },
          "rangeConfidence": {
            "enum": [
              "manual_research",
              "estimated",
              "high",
              "low",
              "unknown"
            ],
            "type": "string",
            "description": "How the range was established, strongest first. \"manual_research\" was researched against sheet music or a score and is the most trustworthy tier. \"estimated\" was derived from published sources rather than measured, so present those scores as guidance rather than fact. \"high\" and \"low\" are legacy confidence labels. \"unknown\" means no range data."
          },
          "voiceTypeFitScore": {
            "type": "integer",
            "description": "Fit against the voice type lane, 0-100. Can be high while matchScore is low when the range still exceeds the singer."
          }
        }
      },
      "description": "Ranked best matches overall."
    },
    "vocalId": {
      "type": "string"
    },
    "easyWins": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "slug",
          "title",
          "artist",
          "rangeConfidence"
        ],
        "properties": {
          "url": {
            "type": "string",
            "description": "Canonical HumMatch page for the song."
          },
          "slug": {
            "type": "string",
            "description": "Catalog slug; the identifier check_song_fit takes."
          },
          "year": {
            "type": [
              "integer",
              "null"
            ]
          },
          "genre": {
            "type": "string"
          },
          "title": {
            "type": "string"
          },
          "artist": {
            "type": "string"
          },
          "lowNote": {
            "type": [
              "integer",
              "null"
            ],
            "description": "Lowest note of the song as a MIDI number."
          },
          "highNote": {
            "type": [
              "integer",
              "null"
            ],
            "description": "Highest note of the song as a MIDI number."
          },
          "whyItFits": {
            "type": "string"
          },
          "matchScore": {
            "type": "integer",
            "description": "Overall suitability for this voice, 0-100."
          },
          "lowNoteName": {
            "type": "string",
            "description": "Same as lowNote, as a note name like \"G2\"."
          },
          "rangeSource": {
            "type": "string",
            "description": "Provenance tag for the range, e.g. \"estimated_curated_seed\"."
          },
          "riskWarning": {
            "type": "string"
          },
          "highNoteName": {
            "type": "string",
            "description": "Same as highNote, as a note name like \"C#5\"."
          },
          "suggestedKey": {
            "type": "string",
            "description": "Transposition advice, e.g. \"Try a lower key\"."
          },
          "vocalFitScore": {
            "type": "integer",
            "description": "How well the song range sits inside the singer range, 0-100."
          },
          "likelyVoiceFit": {
            "type": "string"
          },
          "tessituraScore": {
            "type": "integer",
            "description": "How comfortable the song sits where the voice spends most time, 0-100."
          },
          "difficultyScore": {
            "type": [
              "integer",
              "null"
            ],
            "description": "Karaoke difficulty, 0-100. Higher is harder."
          },
          "rangeConfidence": {
            "enum": [
              "manual_research",
              "estimated",
              "high",
              "low",
              "unknown"
            ],
            "type": "string",
            "description": "How the range was established, strongest first. \"manual_research\" was researched against sheet music or a score and is the most trustworthy tier. \"estimated\" was derived from published sources rather than measured, so present those scores as guidance rather than fact. \"high\" and \"low\" are legacy confidence labels. \"unknown\" means no range data."
          },
          "voiceTypeFitScore": {
            "type": "integer",
            "description": "Fit against the voice type lane, 0-100. Can be high while matchScore is low when the range still exceeds the singer."
          }
        }
      },
      "description": "Comfortable and easy to sing."
    },
    "rangeLow": {
      "type": "integer"
    },
    "rangeHigh": {
      "type": "integer"
    },
    "voiceType": {
      "type": "string"
    },
    "bestSafePicks": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "slug",
          "title",
          "artist",
          "rangeConfidence"
        ],
        "properties": {
          "url": {
            "type": "string",
            "description": "Canonical HumMatch page for the song."
          },
          "slug": {
            "type": "string",
            "description": "Catalog slug; the identifier check_song_fit takes."
          },
          "year": {
            "type": [
              "integer",
              "null"
            ]
          },
          "genre": {
            "type": "string"
          },
          "title": {
            "type": "string"
          },
          "artist": {
            "type": "string"
          },
          "lowNote": {
            "type": [
              "integer",
              "null"
            ],
            "description": "Lowest note of the song as a MIDI number."
          },
          "highNote": {
            "type": [
              "integer",
              "null"
            ],
            "description": "Highest note of the song as a MIDI number."
          },
          "whyItFits": {
            "type": "string"
          },
          "matchScore": {
            "type": "integer",
            "description": "Overall suitability for this voice, 0-100."
          },
          "lowNoteName": {
            "type": "string",
            "description": "Same as lowNote, as a note name like \"G2\"."
          },
          "rangeSource": {
            "type": "string",
            "description": "Provenance tag for the range, e.g. \"estimated_curated_seed\"."
          },
          "riskWarning": {
            "type": "string"
          },
          "highNoteName": {
            "type": "string",
            "description": "Same as highNote, as a note name like \"C#5\"."
          },
          "suggestedKey": {
            "type": "string",
            "description": "Transposition advice, e.g. \"Try a lower key\"."
          },
          "vocalFitScore": {
            "type": "integer",
            "description": "How well the song range sits inside the singer range, 0-100."
          },
          "likelyVoiceFit": {
            "type": "string"
          },
          "tessituraScore": {
            "type": "integer",
            "description": "How comfortable the song sits where the voice spends most time, 0-100."
          },
          "difficultyScore": {
            "type": [
              "integer",
              "null"
            ],
            "description": "Karaoke difficulty, 0-100. Higher is harder."
          },
          "rangeConfidence": {
            "enum": [
              "manual_research",
              "estimated",
              "high",
              "low",
              "unknown"
            ],
            "type": "string",
            "description": "How the range was established, strongest first. \"manual_research\" was researched against sheet music or a score and is the most trustworthy tier. \"estimated\" was derived from published sources rather than measured, so present those scores as guidance rather than fact. \"high\" and \"low\" are legacy confidence labels. \"unknown\" means no range data."
          },
          "voiceTypeFitScore": {
            "type": "integer",
            "description": "Fit against the voice type lane, 0-100. Can be high while matchScore is low when the range still exceeds the singer."
          }
        }
      },
      "description": "Lowest-risk choices."
    },
    "groupFriendly": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "slug",
          "title",
          "artist",
          "rangeConfidence"
        ],
        "properties": {
          "url": {
            "type": "string",
            "description": "Canonical HumMatch page for the song."
          },
          "slug": {
            "type": "string",
            "description": "Catalog slug; the identifier check_song_fit takes."
          },
          "year": {
            "type": [
              "integer",
              "null"
            ]
          },
          "genre": {
            "type": "string"
          },
          "title": {
            "type": "string"
          },
          "artist": {
            "type": "string"
          },
          "lowNote": {
            "type": [
              "integer",
              "null"
            ],
            "description": "Lowest note of the song as a MIDI number."
          },
          "highNote": {
            "type": [
              "integer",
              "null"
            ],
            "description": "Highest note of the song as a MIDI number."
          },
          "whyItFits": {
            "type": "string"
          },
          "matchScore": {
            "type": "integer",
            "description": "Overall suitability for this voice, 0-100."
          },
          "lowNoteName": {
            "type": "string",
            "description": "Same as lowNote, as a note name like \"G2\"."
          },
          "rangeSource": {
            "type": "string",
            "description": "Provenance tag for the range, e.g. \"estimated_curated_seed\"."
          },
          "riskWarning": {
            "type": "string"
          },
          "highNoteName": {
            "type": "string",
            "description": "Same as highNote, as a note name like \"C#5\"."
          },
          "suggestedKey": {
            "type": "string",
            "description": "Transposition advice, e.g. \"Try a lower key\"."
          },
          "vocalFitScore": {
            "type": "integer",
            "description": "How well the song range sits inside the singer range, 0-100."
          },
          "likelyVoiceFit": {
            "type": "string"
          },
          "tessituraScore": {
            "type": "integer",
            "description": "How comfortable the song sits where the voice spends most time, 0-100."
          },
          "difficultyScore": {
            "type": [
              "integer",
              "null"
            ],
            "description": "Karaoke difficulty, 0-100. Higher is harder."
          },
          "rangeConfidence": {
            "enum": [
              "manual_research",
              "estimated",
              "high",
              "low",
              "unknown"
            ],
            "type": "string",
            "description": "How the range was established, strongest first. \"manual_research\" was researched against sheet music or a score and is the most trustworthy tier. \"estimated\" was derived from published sources rather than measured, so present those scores as guidance rather than fact. \"high\" and \"low\" are legacy confidence labels. \"unknown\" means no range data."
          },
          "voiceTypeFitScore": {
            "type": "integer",
            "description": "Fit against the voice type lane, 0-100. Can be high while matchScore is low when the range still exceeds the singer."
          }
        }
      },
      "description": "Work well with other singers."
    },
    "confidenceTier": {
      "type": "string"
    },
    "riskyPicksToAvoid": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "slug",
          "title",
          "artist",
          "rangeConfidence"
        ],
        "properties": {
          "url": {
            "type": "string",
            "description": "Canonical HumMatch page for the song."
          },
          "slug": {
            "type": "string",
            "description": "Catalog slug; the identifier check_song_fit takes."
          },
          "year": {
            "type": [
              "integer",
              "null"
            ]
          },
          "genre": {
            "type": "string"
          },
          "title": {
            "type": "string"
          },
          "artist": {
            "type": "string"
          },
          "lowNote": {
            "type": [
              "integer",
              "null"
            ],
            "description": "Lowest note of the song as a MIDI number."
          },
          "highNote": {
            "type": [
              "integer",
              "null"
            ],
            "description": "Highest note of the song as a MIDI number."
          },
          "whyItFits": {
            "type": "string"
          },
          "matchScore": {
            "type": "integer",
            "description": "Overall suitability for this voice, 0-100."
          },
          "lowNoteName": {
            "type": "string",
            "description": "Same as lowNote, as a note name like \"G2\"."
          },
          "rangeSource": {
            "type": "string",
            "description": "Provenance tag for the range, e.g. \"estimated_curated_seed\"."
          },
          "riskWarning": {
            "type": "string"
          },
          "highNoteName": {
            "type": "string",
            "description": "Same as highNote, as a note name like \"C#5\"."
          },
          "suggestedKey": {
            "type": "string",
            "description": "Transposition advice, e.g. \"Try a lower key\"."
          },
          "vocalFitScore": {
            "type": "integer",
            "description": "How well the song range sits inside the singer range, 0-100."
          },
          "likelyVoiceFit": {
            "type": "string"
          },
          "tessituraScore": {
            "type": "integer",
            "description": "How comfortable the song sits where the voice spends most time, 0-100."
          },
          "difficultyScore": {
            "type": [
              "integer",
              "null"
            ],
            "description": "Karaoke difficulty, 0-100. Higher is harder."
          },
          "rangeConfidence": {
            "enum": [
              "manual_research",
              "estimated",
              "high",
              "low",
              "unknown"
            ],
            "type": "string",
            "description": "How the range was established, strongest first. \"manual_research\" was researched against sheet music or a score and is the most trustworthy tier. \"estimated\" was derived from published sources rather than measured, so present those scores as guidance rather than fact. \"high\" and \"low\" are legacy confidence labels. \"unknown\" means no range data."
          },
          "voiceTypeFitScore": {
            "type": "integer",
            "description": "Fit against the voice type lane, 0-100. Can be high while matchScore is low when the range still exceeds the singer."
          }
        }
      },
      "description": "Scored, but they exceed the comfortable range."
    },
    "popularCrowdPleasers": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "slug",
          "title",
          "artist",
          "rangeConfidence"
        ],
        "properties": {
          "url": {
            "type": "string",
            "description": "Canonical HumMatch page for the song."
          },
          "slug": {
            "type": "string",
            "description": "Catalog slug; the identifier check_song_fit takes."
          },
          "year": {
            "type": [
              "integer",
              "null"
            ]
          },
          "genre": {
            "type": "string"
          },
          "title": {
            "type": "string"
          },
          "artist": {
            "type": "string"
          },
          "lowNote": {
            "type": [
              "integer",
              "null"
            ],
            "description": "Lowest note of the song as a MIDI number."
          },
          "highNote": {
            "type": [
              "integer",
              "null"
            ],
            "description": "Highest note of the song as a MIDI number."
          },
          "whyItFits": {
            "type": "string"
          },
          "matchScore": {
            "type": "integer",
            "description": "Overall suitability for this voice, 0-100."
          },
          "lowNoteName": {
            "type": "string",
            "description": "Same as lowNote, as a note name like \"G2\"."
          },
          "rangeSource": {
            "type": "string",
            "description": "Provenance tag for the range, e.g. \"estimated_curated_seed\"."
          },
          "riskWarning": {
            "type": "string"
          },
          "highNoteName": {
            "type": "string",
            "description": "Same as highNote, as a note name like \"C#5\"."
          },
          "suggestedKey": {
            "type": "string",
            "description": "Transposition advice, e.g. \"Try a lower key\"."
          },
          "vocalFitScore": {
            "type": "integer",
            "description": "How well the song range sits inside the singer range, 0-100."
          },
          "likelyVoiceFit": {
            "type": "string"
          },
          "tessituraScore": {
            "type": "integer",
            "description": "How comfortable the song sits where the voice spends most time, 0-100."
          },
          "difficultyScore": {
            "type": [
              "integer",
              "null"
            ],
            "description": "Karaoke difficulty, 0-100. Higher is harder."
          },
          "rangeConfidence": {
            "enum": [
              "manual_research",
              "estimated",
              "high",
              "low",
              "unknown"
            ],
            "type": "string",
            "description": "How the range was established, strongest first. \"manual_research\" was researched against sheet music or a score and is the most trustworthy tier. \"estimated\" was derived from published sources rather than measured, so present those scores as guidance rather than fact. \"high\" and \"low\" are legacy confidence labels. \"unknown\" means no range data."
          },
          "voiceTypeFitScore": {
            "type": "integer",
            "description": "Fit against the voice type lane, 0-100. Can be high while matchScore is low when the range still exceeds the singer."
          }
        }
      },
      "description": "Well-known songs that still fit."
    }
  }
}
recommend_songs annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
search_songs — Search the song catalog
Advertised by the server during the last successful anonymous check.
Advertised read-only

Search HumMatch by song title or artist. Use this to resolve a song someone named into the catalog slug that check_song_fit needs, or to look up a song's measured vocal range. Pass rangeLow/rangeHigh as well to score every result against that voice and get the hits ranked by fit.

search_songs input schema
{
  "type": "object",
  "required": [
    "q"
  ],
  "properties": {
    "q": {
      "type": "string",
      "description": "Search text: a song title, an artist, or both."
    },
    "limit": {
      "type": "integer",
      "description": "Maximum results (default 20, max 50)."
    },
    "rangeLow": {
      "type": "string",
      "description": "Optional. Lowest note of the singer, to score and rank the results by fit."
    },
    "rangeHigh": {
      "type": "string",
      "description": "Optional. Highest note of the singer, to score and rank the results by fit."
    }
  },
  "additionalProperties": false
}
search_songs output schema
{
  "type": "object",
  "required": [
    "query",
    "songs"
  ],
  "properties": {
    "count": {
      "type": "integer"
    },
    "query": {
      "type": "string"
    },
    "songs": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "slug",
          "title",
          "artist",
          "rangeConfidence"
        ],
        "properties": {
          "url": {
            "type": "string",
            "description": "Canonical HumMatch page for the song."
          },
          "slug": {
            "type": "string",
            "description": "Catalog slug; the identifier check_song_fit takes."
          },
          "year": {
            "type": [
              "integer",
              "null"
            ]
          },
          "genre": {
            "type": "string"
          },
          "title": {
            "type": "string"
          },
          "artist": {
            "type": "string"
          },
          "lowNote": {
            "type": [
              "integer",
              "null"
            ],
            "description": "Lowest note of the song as a MIDI number."
          },
          "highNote": {
            "type": [
              "integer",
              "null"
            ],
            "description": "Highest note of the song as a MIDI number."
          },
          "whyItFits": {
            "type": "string"
          },
          "matchScore": {
            "type": "integer",
            "description": "Overall suitability for this voice, 0-100."
          },
          "lowNoteName": {
            "type": "string",
            "description": "Same as lowNote, as a note name like \"G2\"."
          },
          "rangeSource": {
            "type": "string",
            "description": "Provenance tag for the range, e.g. \"estimated_curated_seed\"."
          },
          "riskWarning": {
            "type": "string"
          },
          "highNoteName": {
            "type": "string",
            "description": "Same as highNote, as a note name like \"C#5\"."
          },
          "suggestedKey": {
            "type": "string",
            "description": "Transposition advice, e.g. \"Try a lower key\"."
          },
          "vocalFitScore": {
            "type": "integer",
            "description": "How well the song range sits inside the singer range, 0-100."
          },
          "likelyVoiceFit": {
            "type": "string"
          },
          "tessituraScore": {
            "type": "integer",
            "description": "How comfortable the song sits where the voice spends most time, 0-100."
          },
          "difficultyScore": {
            "type": [
              "integer",
              "null"
            ],
            "description": "Karaoke difficulty, 0-100. Higher is harder."
          },
          "rangeConfidence": {
            "enum": [
              "manual_research",
              "estimated",
              "high",
              "low",
              "unknown"
            ],
            "type": "string",
            "description": "How the range was established, strongest first. \"manual_research\" was researched against sheet music or a score and is the most trustworthy tier. \"estimated\" was derived from published sources rather than measured, so present those scores as guidance rather than fact. \"high\" and \"low\" are legacy confidence labels. \"unknown\" means no range data."
          },
          "voiceTypeFitScore": {
            "type": "integer",
            "description": "Fit against the voice type lane, 0-100. Can be high while matchScore is low when the range still exceeds the singer."
          }
        }
      },
      "description": "Results. Scored fields are present only when rangeLow and rangeHigh were supplied."
    }
  }
}
search_songs annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
check_song_fit — Score one song for a voice
Advertised by the server during the last successful anonymous check.
Advertised read-only

Score a specific catalog song against a singer's range and explain why it fits or does not, including a suggested key to transpose to. Call this when someone asks whether they can sing a particular song. Resolve the song with search_songs first to get its slug.

check_song_fit input schema
{
  "type": "object",
  "required": [
    "slug",
    "rangeLow",
    "rangeHigh"
  ],
  "properties": {
    "slug": {
      "type": "string",
      "description": "The catalog slug of the song, from search_songs."
    },
    "rangeLow": {
      "type": "string",
      "description": "Lowest comfortable note, as a note name like \"D3\" or a raw MIDI number."
    },
    "rangeHigh": {
      "type": "string",
      "description": "Highest comfortable note, as a note name like \"C5\" or a raw MIDI number."
    },
    "voiceType": {
      "type": "string",
      "description": "Optional voice type hint (soprano, mezzo, alto, tenor, baritone, bass). Inferred from the range when omitted."
    }
  },
  "additionalProperties": false
}
check_song_fit output schema
{
  "type": "object",
  "required": [
    "slug",
    "title",
    "artist",
    "matchScore",
    "rangeConfidence"
  ],
  "properties": {
    "url": {
      "type": "string",
      "description": "Canonical HumMatch page for the song."
    },
    "slug": {
      "type": "string",
      "description": "Catalog slug; the identifier check_song_fit takes."
    },
    "year": {
      "type": [
        "integer",
        "null"
      ]
    },
    "genre": {
      "type": "string"
    },
    "title": {
      "type": "string"
    },
    "artist": {
      "type": "string"
    },
    "reason": {
      "type": "string",
      "description": "Plain-language verdict."
    },
    "lowNote": {
      "type": [
        "integer",
        "null"
      ],
      "description": "Lowest note of the song as a MIDI number."
    },
    "highNote": {
      "type": [
        "integer",
        "null"
      ],
      "description": "Highest note of the song as a MIDI number."
    },
    "whyItFits": {
      "type": "string"
    },
    "fitDetails": {
      "type": "object",
      "properties": {
        "riskLabel": {
          "type": "string",
          "description": "e.g. \"May be too high\"."
        },
        "missingRange": {
          "type": "boolean"
        },
        "priorityTier": {
          "type": "integer"
        },
        "toneReliable": {
          "type": "boolean"
        },
        "trustPhrases": {
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "rangeFitLabel": {
          "type": "string",
          "description": "e.g. \"Comfortable\", \"Exploratory\"."
        },
        "likelyVoiceFit": {
          "type": "string"
        },
        "familiarityTier": {
          "type": "string"
        },
        "voiceTypeFitLabel": {
          "type": "string"
        },
        "catalogQualityLabel": {
          "type": "string"
        },
        "reviewedSongProfile": {
          "type": "boolean"
        }
      },
      "description": "Labels behind the scores."
    },
    "matchScore": {
      "type": "integer",
      "description": "Overall suitability for this voice, 0-100."
    },
    "lowNoteName": {
      "type": "string",
      "description": "Same as lowNote, as a note name like \"G2\"."
    },
    "rangeSource": {
      "type": "string",
      "description": "Provenance tag for the range, e.g. \"estimated_curated_seed\"."
    },
    "riskWarning": {
      "type": "string"
    },
    "highNoteName": {
      "type": "string",
      "description": "Same as highNote, as a note name like \"C#5\"."
    },
    "suggestedKey": {
      "type": "string",
      "description": "Transposition advice, e.g. \"Try a lower key\"."
    },
    "vocalFitScore": {
      "type": "integer",
      "description": "How well the song range sits inside the singer range, 0-100."
    },
    "likelyVoiceFit": {
      "type": "string"
    },
    "tessituraScore": {
      "type": "integer",
      "description": "How comfortable the song sits where the voice spends most time, 0-100."
    },
    "difficultyScore": {
      "type": [
        "integer",
        "null"
      ],
      "description": "Karaoke difficulty, 0-100. Higher is harder."
    },
    "rangeConfidence": {
      "enum": [
        "manual_research",
        "estimated",
        "high",
        "low",
        "unknown"
      ],
      "type": "string",
      "description": "How the range was established, strongest first. \"manual_research\" was researched against sheet music or a score and is the most trustworthy tier. \"estimated\" was derived from published sources rather than measured, so present those scores as guidance rather than fact. \"high\" and \"low\" are legacy confidence labels. \"unknown\" means no range data."
    },
    "voiceTypeFitScore": {
      "type": "integer",
      "description": "Fit against the voice type lane, 0-100. Can be high while matchScore is low when the range still exceeds the singer."
    }
  }
}
check_song_fit annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
group_song_fit — Find songs a group can sing together
Advertised by the server during the last successful anonymous check.
Advertised read-only

Given two or more singers' ranges, find the vocal range they share and the songs that sit inside it. Call this for karaoke night with friends, a duet, a choir or worship team, or any "what can we all sing" question.

group_song_fit input schema
{
  "type": "object",
  "required": [
    "profiles"
  ],
  "properties": {
    "profiles": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "rangeLow",
          "rangeHigh"
        ],
        "properties": {
          "id": {
            "type": "string",
            "description": "Optional label for this singer, e.g. their name."
          },
          "rangeLow": {
            "type": "string",
            "description": "Lowest note, as a note name or MIDI number."
          },
          "rangeHigh": {
            "type": "string",
            "description": "Highest note, as a note name or MIDI number."
          }
        }
      },
      "minItems": 2,
      "description": "Two or more singers, each with a rangeLow and rangeHigh."
    }
  },
  "additionalProperties": false
}
group_song_fit output schema
{
  "type": "object",
  "required": [
    "sharedRange",
    "songs"
  ],
  "properties": {
    "songs": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "slug",
          "title",
          "artist"
        ],
        "properties": {
          "url": {
            "type": "string",
            "description": "Canonical HumMatch page for the song."
          },
          "slug": {
            "type": "string",
            "description": "Catalog slug; the identifier check_song_fit takes."
          },
          "year": {
            "type": [
              "integer",
              "null"
            ]
          },
          "genre": {
            "type": "string"
          },
          "title": {
            "type": "string"
          },
          "artist": {
            "type": "string"
          },
          "reason": {
            "type": "string"
          },
          "lowNote": {
            "type": [
              "integer",
              "null"
            ],
            "description": "Lowest note of the song as a MIDI number."
          },
          "fitLabel": {
            "type": "string",
            "description": "e.g. \"Group-ready\", \"Higher-risk\"."
          },
          "highNote": {
            "type": [
              "integer",
              "null"
            ],
            "description": "Highest note of the song as a MIDI number."
          },
          "difficulty": {
            "type": "string",
            "description": "Label, e.g. \"Easy win\", \"Moderate\". Note this is a string here, unlike difficultyScore elsewhere."
          },
          "lowNoteName": {
            "type": "string",
            "description": "Same as lowNote, as a note name like \"G2\"."
          },
          "rangeSource": {
            "type": "string",
            "description": "Provenance tag for the range, e.g. \"estimated_curated_seed\"."
          },
          "highNoteName": {
            "type": "string",
            "description": "Same as highNote, as a note name like \"C#5\"."
          },
          "fitsMemberIds": {
            "type": "array",
            "items": {
              "type": "string"
            },
            "description": "Which supplied singers can sing it, by their id. Shorter than the full group means a partial fit."
          },
          "rangeConfidence": {
            "enum": [
              "manual_research",
              "estimated",
              "high",
              "low",
              "unknown"
            ],
            "type": "string",
            "description": "How the range was established, strongest first. \"manual_research\" was researched against sheet music or a score and is the most trustworthy tier. \"estimated\" was derived from published sources rather than measured, so present those scores as guidance rather than fact. \"high\" and \"low\" are legacy confidence labels. \"unknown\" means no range data."
          }
        }
      }
    },
    "sharedRange": {
      "type": "object",
      "properties": {
        "low": {
          "type": [
            "integer",
            "null"
          ]
        },
        "high": {
          "type": [
            "integer",
            "null"
          ]
        },
        "lowName": {
          "type": "string"
        },
        "highName": {
          "type": "string"
        }
      },
      "description": "The overlap every supplied singer can reach. Null bounds mean no shared range exists."
    }
  }
}
group_song_fit annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}

Prompts

Not advertised

No prompt definitions available.

Resources

1 advertised

hummatch-matches-widget

Advertised by the server during the last successful anonymous check.

Scored song matches for a singer's vocal range, as cards.

hummatch-matches-widget URI
ui://widget/hummatch-matches.html

MIME type: text/html+skybridge

90-day uptime

A lightweight connection check about every six hours, sampled on hosts with many listings. It shows the server answered, not that its tools work.

Too few checks for a percentage yet (1 of 1 answered).

  1. 2026-11-07: 1 of 1 checks answered

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

Maintenance history

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

  • · probe · passed · 646 ms · metadata changed · 5 tool(s), 1 resource(s); warnings: Advertises resources/templates/list but does not implement it

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 hummatch-mcp https://hummatch.me/api/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 hummatch-mcp --url https://hummatch.me/api/mcp

Cursor

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

Cline

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

VS Code

Merge this server into .vscode/mcp.json. Use MCP: List Servers to start hummatch-mcp and inspect its tools.
VS Code configuration
{
  "servers": {
    "hummatch-mcp": {
      "type": "http",
      "url": "https://hummatch.me/api/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 hummatch-mcp https://hummatch.me/api/mcp

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://hummatch.me/api/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": {
    "hummatch-mcp": {
      "serverUrl": "https://hummatch.me/api/mcp"
    }
  }
}

Let your agent find its tools

Find servers like HumMatch 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 HumMatch 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