Skip to main content
Glama
elad12390

notification-mcp

by elad12390

notification-mcp

An MCP server that lets AI assistants send spoken audio notifications using high-quality AI voices. When an AI finishes a long task, it can call the notify tool to speak a message aloud — so you don't have to stare at the screen waiting.

Powered by Kokoro TTS (fast, expressive, 26 voices), with optional F5-TTS (higher quality, voice cloning) and macOS say (instant, no setup).

Quick Start

Prerequisites

  • macOS (notifications play via afplay)

  • Node.js 18+

  • uv — Python package runner (for Kokoro/F5-TTS)

    curl -LsSf https://astral.sh/uv/install.sh | sh

Install via npx

No installation needed — run directly with npx:

{
  "mcpServers": {
    "notification-mcp": {
      "command": "npx",
      "args": ["-y", "@elad12390/notification-mcp"]
    }
  }
}

Install from source

git clone https://github.com/elad12390/notification-mcp.git
cd notification-mcp
npm install
npm run build

Then configure your MCP client (see Configuration below).

Related MCP server: ntfy-me-mcp

Configuration

Claude Desktop

Add to ~/Library/Application Support/Claude/claude_desktop_config.json:

{
  "mcpServers": {
    "notification-mcp": {
      "command": "npx",
      "args": ["-y", "@elad12390/notification-mcp"]
    }
  }
}

OpenCode / Cursor / Other MCP Clients

{
  "mcpServers": {
    "notification-mcp": {
      "command": "npx",
      "args": ["-y", "@elad12390/notification-mcp"]
    }
  }
}

From source

{
  "mcpServers": {
    "notification-mcp": {
      "command": "node",
      "args": ["/path/to/notification-mcp/dist/index.js"]
    }
  }
}

The notify Tool

Once configured, the AI can call:

notify(message: "Hey! Build succeeded, all tests passed.")
notify(message: "Done. Your file has been exported.", title: "Export Complete")
notify(message: "Hmm... something looks off. Check the logs.", voice: "george")

Writing Expressive Messages

Kokoro reads punctuation expressively. Write like you'd want it spoken:

Punctuation

Effect

Example

!

Excited/energetic

"Great job!"

...

Long pause, thoughtful

"Wait... what?"

,

Brief natural pause

"Well, I think so"

?

Rising intonation

"Really?"

.

Sentence break

"Done. Everything worked."

Good examples:

"Hey! Your task is complete. Everything went smoothly."
"Hmm... I found something interesting. Check this out!"
"Done! The build succeeded, and all 47 tests passed."

Custom Pronunciation (IPA)

For words that need specific pronunciation, use [word](/IPA/] syntax:

"[Chaim](/χaim/) said hello"     → Hebrew name with guttural ח
"[Elad](/ɛlɑd/) is working"      → Pronounce as "eh-lahd"  
"The [route](/ruːt/) is clear"    → British-style pronunciation

Common IPA symbols: χ (Hebrew ח), ʃ (sh), ð (the), θ (think), ŋ (ng), ɹ (American r)

Voices

Kokoro Voices (default engine)

Use friendly aliases or full voice names:

Alias

Full Name

Accent

heart

af_heart

American Female

bella

af_bella

American Female

nicole

af_nicole

American Female

sarah

af_sarah

American Female

adam

am_adam

American Male

michael

am_michael

American Male

emma

bf_emma

British Female

george

bm_george

British Male

Additional full names: af_alloy, af_aoede, af_jessica, af_kore, af_nova, af_river, af_sky, am_echo, am_eric, am_fenrir, am_liam, am_onyx, am_puck, bf_alice, bf_isabella, bf_lily, bm_daniel, bm_fable, bm_lewis

TTS Engines

Set NOTIFICATION_METHOD to choose your engine:

Engine

Speed

Quality

Requires

kokoro (default)

~3–5s

Great, expressive

uv

f5tts

~10–15s

Highest, voice cloning

uv + FFmpeg

say

Instant

Robotic

Nothing (macOS built-in)

Environment Variables

Variable

Default

Description

NOTIFICATION_METHOD

kokoro

TTS engine: kokoro, f5tts, or say

KOKORO_VOICE

af_heart

Default Kokoro voice (alias or full name)

KOKORO_SPEED

1.0

Kokoro speech speed multiplier

F5TTS_SPEED

1.0

F5-TTS speech speed multiplier

F5TTS_REF_AUDIO

Path to reference audio file for voice cloning

F5TTS_REF_TEXT

Transcript of the reference audio

SAY_VOICE

Samantha

macOS say voice name

LOG_LEVEL

info

Log level: debug, info, warn, error, silent

MCP_METRICS_ENABLED

true

Enable/disable usage metrics

Example: Use a British male voice by default

{
  "mcpServers": {
    "notification-mcp": {
      "command": "npx",
      "args": ["-y", "@elad12390/notification-mcp"],
      "env": {
        "KOKORO_VOICE": "bm_george",
        "KOKORO_SPEED": "1.1"
      }
    }
  }
}

Example: Use F5-TTS with custom voice cloning

{
  "mcpServers": {
    "notification-mcp": {
      "command": "npx",
      "args": ["-y", "@elad12390/notification-mcp"],
      "env": {
        "NOTIFICATION_METHOD": "f5tts",
        "F5TTS_REF_AUDIO": "/path/to/your-voice.wav",
        "F5TTS_REF_TEXT": "Transcript of what is said in that audio file."
      }
    }
  }
}

Development

# Install dependencies
npm install

# Development with hot reload
npm run dev

# Build
npm run build

# Run tests
npm test

# Run with coverage
npm run test:coverage

License

MIT

Available Tools

2 tools
notifyA

Sends a notification to the user. Use this when you complete a task and want to alert the user.

IMPORTANT - Writing expressive messages:

  • Use punctuation naturally: "Hello!" sounds excited, "Hello..." sounds thoughtful

  • Use commas for pauses: "Well, I think so" has a natural pause

  • Use ellipsis for longer pauses: "Wait... what?"

  • Exclamation marks add energy: "Great job!" vs "Great job."

  • Question marks affect intonation: "Really?" sounds curious

  • Break long messages into sentences for natural rhythm

  • The model reads punctuation expressively, so write like you'd want it spoken!

Example good messages:

  • "Hey! Your task is complete. Everything went smoothly."

  • "Hmm... I found something interesting. Check this out!"

  • "Done! The build succeeded, and all tests passed."

CUSTOM PRONUNCIATION (IPA): For words that need specific pronunciation, use: [word](/IPA phonemes/) Common IPA symbols:

  • χ = Hebrew ח (chet), guttural "kh" sound

  • ʃ = "sh" sound

  • ð = "th" in "the"

  • θ = "th" in "think"

  • ŋ = "ng" sound

  • ɹ = American "r"

Examples:

  • "Chaim" - Hebrew name with guttural ח

  • "Elad" - Pronounce as "eh-lahd"

  • "Hello world!" - Custom pronunciation for "world"

TTS ENGINE OPTIONS (set via NOTIFICATION_METHOD env var):

  • "kokoro" (default): Fast (~3-5s), built-in voices, IPA pronunciation support

  • "f5tts": Higher quality (flow matching), slower (~10-15s), voice cloning capable

  • "say": macOS built-in, fastest but robotic

ParametersJSON Schema
NameRequiredDescriptionDefault
titleNoOptional title for the notification (spoken before the message with a pause)
voiceNoVoice to use. For Kokoro: heart, bella, nicole, sarah, adam, michael, emma, george (or full names like af_heart, bm_george). For macOS say: Samantha, Daniel, etc. For F5-TTS: uses bundled voice or custom via F5TTS_REF_AUDIO env.
messageYesThe notification message. Write naturally with punctuation for expressive speech: use '!' for excitement, '...' for pauses, ',' for brief pauses, '?' for questions. Example: 'Hey! Your task is done. Everything worked perfectly.'
reasoningYesExplain why you are using this tool - helps track usage patterns and optimize the server

TDQS

A3.5/5.0
Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full behavioral burden. It does add genuine operational context — the NOTIFICATION_METHOD env var, per-engine latency (~3-5s vs ~10-15s), and voice-cloning capability — but says nothing about failure behavior, permissions, or whether the call blocks until speech finishes.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness3/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The purpose is correctly front-loaded, but the body is heavily padded: the punctuation/expressiveness section restates guidance already present in the message parameter's schema description, and stacks multiple redundant examples. Only the IPA syntax and TTS engine sections clearly earn their length.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a 4-parameter tool with no annotations and no output schema, the description covers configuration and message formatting but omits what happens on failure, whether delivery is synchronous, and any environment prerequisites beyond the engine choice. Adequate but with visible holes.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100%, so the voice, message, title, and reasoning parameters are already documented. The description's IPA notation syntax ('[word](/IPA phonemes/)') and symbol table are genuinely absent from the schema, but they only apply to the message payload rather than adding semantics for the parameters themselves, keeping this near the baseline.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The first two sentences give a specific verb and resource ('Sends a notification to the user') plus the triggering condition ('when you complete a task and want to alert the user'). It is clear what the tool does, but it never differentiates itself from the sibling report_issue, so an agent must infer the boundary.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

'Use this when you complete a task and want to alert the user' supplies an explicit trigger condition. There are no when-not conditions and no routing guidance relative to report_issue, so the guidance is clear but incomplete.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

report_issueA

Report a bug, feature request, or other issue with the MCP server. Issues are saved locally for the server maintainer to review.

ParametersJSON Schema
NameRequiredDescriptionDefault
titleYesA brief, descriptive title for the issue
categoryNoType of issue: bug, feature_request, documentation, performance, security, or otherbug
severityNoHow severe is this issue? (low, medium, high, critical)medium
reasoningYesExplain why you are reporting this issue - helps track usage patterns
descriptionYesDetailed description of the issue or request
environmentNoEnvironment details like OS, Node version, or other relevant context
actual_behaviorNoWhat actually happened
expected_behaviorNoWhat you expected to happen
steps_to_reproduceNoStep-by-step instructions to reproduce the issue (for bugs)

TDQS

A3.7/5.0
Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the burden, and it discloses the key behavioral trait an agent needs: issues are 'saved locally' for the maintainer, i.e. this files persistent feedback rather than acting on the server. It doesn't cover side effects like storage location or whether reporting is irreversible, but the local-save behavior is the most important disclosure.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Two short sentences, purpose front-loaded, zero filler. Nothing to trim.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a feedback-reporting tool with no annotations and no output schema, the description covers purpose and storage but omits return/confirmation behavior and how it differs from the 'notify' sibling. Adequate but with clear gaps.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100% and each of the 9 parameters is documented in the schema, so the baseline is 3. The description adds no parameter-level detail beyond naming the issue categories, which the schema already covers via enums.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

Explicit verb+resource ('Report ... issue with the MCP server') and enumerates the issue types it accepts (bug, feature request, other). It doesn't reference the sibling tool 'notify', but the purpose is unambiguous on its own.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies when to use it (you have a bug or request for the MCP server), but offers no exclusions or routing relative to the sibling 'notify' tool. Implied usage only, no when-not guidance.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

  1. 2 tool updatesv3.0.0
    • First observednotify
    • First observedreport_issue

TDQS

A3.7/5.0

Scored across 2 tools

Disambiguation5/5

report_issue and notify serve clearly different purposes: one reports bugs/features about the MCP server, the other sends user-facing notifications. An agent can easily choose the correct tool based on task context.

Naming Consistency4/5

Both names use lowercase snake_case and start with a verb, but report_issue follows a verb_noun pattern while notify is a lone verb. This is a minor inconsistency, not confusing.

Tool Count3/5

With only two tools, the set is thin for a dedicated server, though both tools are distinct and useful. It falls into the borderline 1-2 tool range noted in the rubric.

Completeness4/5

The server covers the core notification action and provides a feedback path via report_issue. Minor gaps exist around notification management or delivery status, but these are not essential for basic use.

Maintenance

ActivityInactive
ResponsivenessNo issues

Related MCP Connectors

Related MCP Servers

  • A
    license
    Not graded
    quality
    D
    maintenance
    An MCP server that plays notification sounds when AI coding assistants like Windsurf or Cursor require user attention, such as when coding is complete or when user approval is needed.
    6 npm
    2
    MIT
  • A
    license
    A
    quality
    C
    maintenance
    A streamlined MCP server that enables AI assistants to send real-time notifications to your devices through the ntfy service, allowing you to receive alerts when tasks complete or important events occur.
    2
    96 npm
    74
    GPL 3.0
  • A
    license
    Not graded
    quality
    D
    maintenance
    An MCP server that enables AI agents to send notifications and request user input via Discord during long-running tasks. It allows users to remotely interact with their AI assistants and provide feedback through the Discord messaging platform.
    26 npm
    2
    MIT
  • F
    license
    Not graded
    quality
    D
    maintenance
    An MCP server that sends webhook notifications to a configured URL, enabling AI assistants to notify users when long-running tasks complete.
    19 npm
    3
    -