Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@SpeechPulse Analyze emotion and urgency in audio file /path/to/call.wav"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Voice Emotion Understanding MCP Server
SpeechPulse analyzes speech audio to detect emotions, assess urgency, and detect sarcasm using prosodic features (pitch, energy, rhythm). Built with pure Python standard library for zero ML dependencies in the Lite tier.
Emotion Detection: Recognizes 7 emotions (happy, excited, angry, sad, tired, anxious, neutral) using coefficient of variation (CV) thresholds
Urgency Assessment: 4-level urgency detection (low, medium, high, critical) based on speaking patterns
Sarcasm Detection: Identifies sarcasm by comparing text sentiment with audio emotion
Zero ML Dependencies: Lite tier uses pure Python standard library (no numpy/scipy/librosa)
MCP Compatible: Exposes tools via Model Context Protocol for integration with Claude Desktop and other MCP clients
Related MCP server: Advanced TTS MCP Server
pip install speechpulsegit clone https://github.com/sophieMiao/speechpulse.git
cd speechpulse
pip install -e ".[dev]"Add to your MCP client configuration (e.g., Claude Desktop):
{
"mcpServers": {
"speechpulse": {
"command": "python",
"args": ["-m", "speechpulse"],
"env": {
"SPEECHPULSE_TIER": "lite"
}
}
}
}from speechpulse.analyzer import SpeechAnalyzer
# Initialize analyzer
analyzer = SpeechAnalyzer()
# Analyze emotion
result = analyzer.analyze("path/to/audio.wav")
print(f"Primary emotion: {result['emotion']['primary']}")
# Assess urgency
urgency = analyzer.assess_urgency("path/to/audio.wav")
print(f"Urgency level: {urgency.level}")
# Detect sarcasm (requires text in Lite tier)
sarcasm = analyzer.detect_sarcasm(
"path/to/audio.wav",
text="这真是太棒了"
)
print(f"Is sarcastic: {sarcasm.is_sarcastic}")
# Full analysis
full = analyzer.full_analysis("path/to/audio.wav", text="我受够了！")
print(full['summary'])
print(full['interpretation'])# Start MCP server with stdio transport (default)
python -m speechpulse
# Start with SSE transport
python -m speechpulse --transport sse --port 8080
# Enable verbose logging
python -m speechpulse -vAnalyze audio for emotion and basic features.
Parameters:
audio_path (string, required): Path to WAV audio file
text (string, optional): Transcription text for context
Returns: Emotion detection results, speaker state, and raw audio features
Assess urgency level from audio prosody.
Parameters:
audio_path (string, required): Path to audio file
text (string, optional): Text for keyword-based urgency detection
Returns: Urgency score, level, and reasoning
Detect sarcasm by comparing text sentiment with audio emotion.
Parameters:
audio_path (string, required): Path to audio file
text (string, optional): Transcription text (recommended)
Returns: Sarcasm detection result with confidence and indicators
Perform complete analysis (emotion + urgency + sarcasm).
Parameters:
audio_path (string, required): Path to audio file
text (string, optional): Transcription text
Returns: Complete analysis with summary and interpretation
Check server health and capabilities.
Returns: Status, version, tier, and available capabilities
speechpulse/
├── types.py # Core data types (AudioFeatures, EmotionResult, etc.)
├── config.py # Configuration management
├── utils.py # Audio loading and processing utilities
├── audio_features.py # Feature extraction (pitch, energy, etc.)
├── emotion.py # CV-based emotion rule engine
├── urgency.py # Urgency assessment logic
├── sarcasm.py # Sarcasm detection
├── analyzer.py # Main analysis pipeline
├── server.py # MCP server implementation
├── asr.py # ASR stub (Standard/Pro tier)
└── ml_emotion.py # ML emotion stub (Pro tier)Pure Python: Uses only wave, struct, math, and array modules
Format Support: WAV files with 8/16/24/32-bit PCM
Resampling: Linear interpolation to 16kHz
Framing: 32ms frames with 50% overlap, Hamming window
Pitch: Autocorrelation-based F0 detection (50-500 Hz range)
Energy: RMS energy per frame
Zero Crossing Rate: Voice/unvoiced discrimination
Silence Ratio: Pause pattern analysis
Uses coefficient of variation (CV = std/mean) to avoid gender bias while maintaining discriminative power:
# Example: Happy emotion rule (using coefficient of variation)
"happy": {
"conditions": [
("pitch_cv", ">", 0.15), # High pitch variation (lively)
("energy_mean", ">", 0.3), # Moderate-high energy
("energy_cv", ">", 0.2), # Energy fluctuation
],
"weight": 0.8,
}Based on 5 factors:
Speaking rate (fast/medium/slow)
Volume level (high/medium/low)
Pitch variation (high/medium/low)
Pause pattern (few/normal/many pauses)
Keyword detection (when text provided)
✅ Rule-based emotion recognition
✅ Prosodic urgency assessment
✅ Keyword-based sarcasm detection
✅ Pure Python (no ML dependencies)
❌ No ASR (provide text manually)
❌ WAV format only
ASR with faster-whisper
Additional audio formats (MP3, FLAC, etc.)
Speaker diarization
Qwen2-Audio integration
Context-aware emotion analysis
Nuanced emotion detection
Real-time streaming
# Clone repository
git clone https://github.com/sophieMiao/speechpulse.git
cd speechpulse
# Create virtual environment
python -m venv venv
source venv/bin/activate # Windows: venv\Scripts\activate
# Install in development mode
pip install -e ".[dev]"# Run all tests
python -m pytest tests/
# Run specific test file
python tests/test_all.py
# Run integration tests
python tests/test_integration.py# Run demo script
python examples/demo.pyEnvironment variables:
Variable | Default | Description |
|
| Service tier (lite/standard/pro) |
|
| Target sample rate |
|
| Analysis frame size |
|
| Frame hop size |
Lite tier requires text for sarcasm detection: Provide transcription via text parameter
WAV format only: Convert other formats to WAV before analysis
Rule-based emotions: ML-based nuanced emotion detection in Pro tier
Optimized for Chinese/English: Full multilingual support in Pro tier
Fork the repository
Create a feature branch (git checkout -b feature/amazing-feature)
Commit changes (git commit -m 'Add amazing feature')
Push to branch (git push origin feature/amazing-feature)
Open a Pull Request
This project is licensed under the MIT License - see the LICENSE file for details.
Built with MCP SDK
Inspired by prosodic analysis research in speech emotion recognition
CV approach based on gender-fair emotion recognition research
GitHub Issues: https://github.com/sophieMiao/speechpulse/issues
Made with ❤️ for voice emotion understanding
Analyze audio for emotion and basic features.
This tool analyzes speech audio to detect the speaker's emotional state and extract basic audio features. For Lite tier, ASR is not included, so provide the 'text' parameter if you have a transcription.
Args: audio_path: Path to the audio file (WAV format supported) text: Optional transcription text for context
Returns: Dictionary containing: - transcription: None for Lite tier (ASR not included) - note: Information about Lite tier limitations - emotion: Object with primary emotion, confidence, secondary emotion, scores - speaker_state: Object with energy_level and stress_indicator - features: Raw audio features (duration, pitch, energy, etc.)
Example: { "transcription": null, "note": "Lite tier does not include ASR...", "emotion": { "primary": "happy", "confidence": 0.85, "secondary": "excited", "scores": {"happy": 0.8, "excited": 0.6, ...} }, "speaker_state": { "energy_level": "high", "stress_indicator": "low" }, "features": {...} }
| Name | Required | Description | Default |
|---|---|---|---|
| audio_path | Yes | ||
| text | No |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It transparently details Lite tier limitations, return structure, and example output. However, it does not disclose prerequisites like file size limits or authentication requirements.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with Args, Returns, and Example sections, front-loading the purpose. It is appropriately sized for a complex tool, though minor trimming could improve conciseness.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity, the description covers inputs, outputs, and limitations comprehensively. It details the return dictionary structure and tier-specific behavior, making it complete enough for effective use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, but the description adds significant meaning: explains audio_path expects WAV format, text is optional transcription. This compensates for the empty schema descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool analyzes audio for emotion and basic features, with specific verb 'analyze' and resource 'audio'. It distinguishes from siblings by focusing on emotion and basic features, but does not explicitly contrast with sibling tools like detect_sarcasm or full_analysis.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides moderate guidance by explaining when to provide the 'text' parameter (for Lite tier without ASR), but does not specify when not to use this tool compared to alternatives like full_analysis or assess_urgency.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Assess urgency level from audio.
This tool evaluates the urgency level of speech based on prosodic features like speaking rate, volume, pitch variation, and pause patterns.
Args: audio_path: Path to the audio file (WAV format supported) text: Optional transcription text for keyword-based urgency detection
Returns: Dictionary containing: - score: Urgency score (0.0 to 1.0) - level: Urgency level ("low", "medium", "high", "critical") - reasoning: List of factors contributing to the urgency assessment - factors: Detailed breakdown of contributing factors
Example: { "score": 0.75, "level": "high", "reasoning": ["Fast speaking rate detected", "High volume variation"], "factors": { "speaking_rate": "fast", "volume_level": "high", "pitch_variation": "high", "pause_pattern": "few_pauses" } }
| Name | Required | Description | Default |
|---|---|---|---|
| audio_path | Yes | ||
| text | No |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It describes the analysis and return values but does not disclose behavioral traits such as required permissions, rate limits, or side effects. The description is functional but lacks deeper behavioral context.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with the purpose and includes a structured docstring with parameter details and an example. It is slightly lengthy but each sentence adds value, though some redundancy could be trimmed.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the presence of an output schema (inferred), the description covers inputs and outputs well, including an example. However, it does not discuss how this tool relates to sibling tools, which would enhance completeness.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema coverage is 0%, so the description compensates by explaining audio_path as a WAV file path and text as an optional transcription. This adds meaningful context beyond the basic type information in the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states that the tool assesses urgency from audio based on prosodic features, distinguishing it from siblings like analyze_audio or detect_sarcasm through the specific focus on urgency and prosodic analysis.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for urgency assessment but does not explicitly state when to use this tool over alternatives like analyze_audio or full_analysis, nor does it provide conditions for when not to use it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Detect sarcasm by comparing text sentiment with audio emotion.
This tool detects sarcasm by analyzing the mismatch between the sentiment of the text and the emotional tone of the audio. For Lite tier, the 'text' parameter is required for accurate detection.
Args: audio_path: Path to the audio file (WAV format supported) text: Transcription text (recommended for Lite tier)
Returns: Dictionary containing: - is_sarcastic: Boolean indicating sarcasm detection - confidence: Confidence score (0.0 to 1.0) - indicators: List of indicators that suggest sarcasm - text_emotion: Detected emotion from text (if available) - audio_emotion: Detected emotion from audio
Example: { "is_sarcastic": true, "confidence": 0.82, "indicators": ["Positive text with negative audio tone"], "text_emotion": "positive", "audio_emotion": "sad" }
| Name | Required | Description | Default |
|---|---|---|---|
| audio_path | Yes | ||
| text | No |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It discloses the detection mechanism (mismatch between text sentiment and audio emotion) and the return structure in detail. It also notes a requirement variance for Lite tier, which is helpful behavioral context.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is moderately concise but includes a full docstring-style Args/Returns section. Some repetition occurs (e.g., 'detect sarcasm' twice). The structure is clear but could be trimmed without losing meaning.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has an output schema (not shown) and the description includes an example output. It covers purpose, parameters, return format, and a usage note. For a specialized tool, this is fairly complete, though it could better differentiate from siblings.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. It explains that audio_path is a path to a WAV file and text is transcription text, recommended for Lite tier. This adds format and usage information beyond the schema's type definitions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'Detect sarcasm by comparing text sentiment with audio emotion.' This provides a specific verb (detect) and resource (sarcasm), and the unique approach (comparison) distinguishes it from siblings like analyze_audio and full_analysis.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description mentions that for Lite tier, the 'text' parameter is recommended for accurate detection, giving some usage context. However, it does not explicitly state when not to use this tool or suggest alternative tools from the sibling list.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Perform complete analysis including emotion, urgency, and sarcasm.
This tool performs a comprehensive analysis of speech audio, combining emotion recognition, urgency assessment, and sarcasm detection into a single coherent result.
Args: audio_path: Path to the audio file (WAV format supported) text: Optional transcription text (recommended for complete analysis)
Returns: Dictionary containing: - summary: Human-readable summary of the analysis - transcription: None for Lite tier (ASR not included) - note: Information about Lite tier limitations - emotion_analysis: Complete emotion analysis results - urgency_assessment: Complete urgency assessment results - sarcasm_detection: Complete sarcasm detection results - raw_features: Raw audio features extracted - interpretation: Contextual interpretation (if text provided)
Example: { "summary": "说话者表现出开心的情绪。带有明显的紧迫感（high级别）。", "transcription": null, "note": "Lite tier does not include ASR...", "emotion_analysis": {...}, "urgency_assessment": {...}, "sarcasm_detection": {...}, "raw_features": {...}, "interpretation": "用户语气急促且带有焦虑情绪；建议尽快联系处理。" }
| Name | Required | Description | Default |
|---|---|---|---|
| audio_path | Yes | ||
| text | No |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It discloses the return structure, Lite tier limitations, and that transcription is not available in the Lite tier. It does not mention side effects, but as an analysis tool this is acceptable.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description includes structured Args, Returns, and an Example. While it is somewhat lengthy, every section adds value. It could be slightly more concise but remains efficient.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description provides a comprehensive overview covering input parameters with formats, a detailed return structure, a concrete example, and limitations. This fully informs the agent of the tool's capabilities and output shape.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, but the description explains each parameter: 'audio_path: Path to the audio file (WAV format supported)' and 'text: Optional transcription text (recommended for complete analysis)'. This adds significant meaning beyond the bare schema types.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description explicitly states it performs 'complete analysis including emotion, urgency, and sarcasm'. This clearly distinguishes it from sibling tools which focus on individual aspects like 'analyze_audio', 'assess_urgency', and 'detect_sarcasm'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description indicates that this tool is for comprehensive analysis and that providing text is recommended. However, it does not explicitly state when to use this tool versus the individual sibling tools, nor does it mention scenarios where this tool should not be used.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Check server health status.
This tool can be used to verify that the SpeechPulse MCP server is running and functioning correctly.
Returns: Dictionary containing: - status: "healthy" or "unhealthy" - version: Server version - tier: Current tier ("lite", "standard", or "pro") - capabilities: List of available capabilities
Example: { "status": "healthy", "version": "0.1.0", "tier": "lite", "capabilities": [ "emotion_analysis", "urgency_assessment", "sarcasm_detection" ] }
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It discloses that the tool returns health status, version, tier, and capabilities, implying a non-destructive read operation. No behavioral traits like side effects or authorization requirements are mentioned, but the simple nature of a health check makes this acceptable.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured: a one-line purpose summary, a brief usage sentence, and a clear list of return fields with an example. Every sentence adds value, and the formatting aids readability.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given zero parameters and a detailed output description (including an example dictionary), the tool is fully specified. The description covers purpose, usage, and return schema, making it self-contained.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has no parameters (schema_coverage 100%). Per guidelines, baseline is 4. The description adds value by detailing the return structure, which compensates for the absence of parameter information.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool checks server health status and lists the returned fields (status, version, tier, capabilities). It uses a specific verb ('check') and resource ('server health'), and is easily distinguished from sibling tools like analyze_audio or detect_sarcasm.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly says the tool can be used to verify that the server is running and functioning correctly, providing clear context. It does not exclude specific scenarios, but for a health check tool, this is adequate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
v0.1.0analyze_audioassess_urgencydetect_sarcasmfull_analysishealth_checkTools have distinct focuses (emotion, urgency, sarcasm, health) but full_analysis overlaps by combining all three analyses, creating potential confusion for an agent choosing between individual and combined tools.
Most tools follow a verb_noun pattern (analyze_audio, assess_urgency, detect_sarcasm) but full_analysis and health_check deviate, mixing noun phrases and lacking consistent verb usage.
With 5 tools, the server covers core audio analysis tasks (emotion, urgency, sarcasm) plus a combined analysis and health check, which is well-scoped and reasonable for the domain.
The set covers emotion, urgency, and sarcasm detection, but lacks a dedicated transcription tool (ASR is optional via parameter) and other potential features like speaker identification, leaving moderate gaps.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
Pronunciation assessment, phoneme scoring, speaker voice ID, audio transcription, speech synthesis.
Hosted speech-to-text + speech emotion/tone analysis for agents. No install; trial keys built in.
Sentiment, toxicity, entity extraction, PII, translation, summary, QA, fraud scoring, safety audit.
Affect analysis, 3D avatar params, empathy hints and somatic emotion decode.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/sophieMiao/speechpulse'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
