# Emotion Wheel Classifier MCP

> Emotion Wheel Classifier maps raw text directly to Plutchik's emotional model, giving you more than just positive or negative sentiment. It identifies the primary emotion, its intensity (Low, Medium, High), and which emotional family it belongs to. You can also calculate complex feelings resulting from combinations of emotions or track how a specific feeling develops in strength over time.

## Overview
- **Category:** psychology
- **Price:** Free
- **Tags:** emotions, plutchik, sentiment, nlp, psychology

## Description

Ever needed to know exactly what a piece of text *feels* like? This MCP connects your agent to the deep structure of human emotion. Instead of just telling you if something is 'good' or 'bad,' it pinpoints the source: Is it Joy, Fear, or Disgust? And how intense is that feeling—is it a faint worry or outright panic?

It takes unstructured text and breaks it down into specific emotional nodes, intensities, and families. Need to understand nuanced customer feedback? You can run raw comments through this MCP to get structured emotional data points. The whole Vinkius catalog hosts hundreds of tools like this one, letting you connect your preferred AI client to specialized services that go far beyond standard keyword searches.

## Tools

### explore_emotional_dyad
It calculates the complex emotion that results when you mix two primary emotions together.

### get_emotion_spectrum
It shows how a single, specific feeling evolves or progresses in strength over time.

### analyze_text_emotion
It reads unstructured text and outputs the primary emotion, its intensity level, and which emotional family it falls into.

## Prompt Examples

**Prompt:** 
```
I feel extremely happy and full of energy!
```

**Response:** 
```
The `analyze_text_emotion` tool identifies the primary emotion as Joy with a High intensity level.
```

**Prompt:** 
```
I am slightly afraid of the dark.
```

**Response:** 
```
The `analyze_text_emotion` tool identifies the primary emotion as Fear with a Low intensity level.
```

**Prompt:** 
```
What happens if I combine Joy and Trust?
```

**Response:** 
```
Using `explore_emotional_dyad` with Joy and Trust results in the complex emotion of Love.
```

## Capabilities

### Classify emotion from text
It analyzes any block of text and returns the core emotion, its strength level (Low, Medium, High), and its associated emotional family.

### Map emotion progression
You can show how a single specific feeling changes in intensity or strength across different scenarios.

### Calculate mixed emotions
It computes the resulting complex emotional state when you combine two distinct primary emotions.

## Use Cases

### Analyzing complaint volume spikes
A CX manager wants to know why complaints spiked last week. They run thousands of service tickets through the MCP and discover that while 'Anger' is high, the underlying emotion family is 'Disgust,' pointing directly to a specific product failure or poor UI element.

### Mapping user journey emotional dips
A UX team uses `get_emotion_spectrum` on session transcripts. They find that after users encounter the payment screen, their initial 'Anticipation' drops sharply into low-level 'Anxiety,' indicating friction in checkout.

### Identifying brand resonance
A marketing team feeds positive social media comments into the MCP. By using `explore_emotional_dyad`, they discover that mentions combining 'Joy' and 'Interest' are consistently resulting in 'Excitement,' confirming a successful campaign angle.

### Filtering academic research data
A psychology student needs to categorize historical texts. They use `analyze_text_emotion` to filter out general positive/negative content and only pull nodes matching specific families, like 'Apprehension' or 'Wonder'.

## Benefits

- Instead of basic sentiment, you get granular data. The `analyze_text_emotion` tool tells you if the user is 'Angry' or just 'Irritated,' along with a specific intensity score.
- Need to understand relationship dynamics? Use `explore_emotional_dyad` to calculate complex emotions. For example, combining Joy and Trust results in Love—a level of detail basic classifiers miss entirely.
- Track emotional shifts over time using `get_emotion_spectrum`. You can plot how a user's initial 'Fear' progresses into 'Anxiety,' giving you a behavioral timeline.
- It moves your data analysis from simple categorization to deep psychological mapping. This is critical for any product relying on nuanced human feedback.
- The structure of the output means your agent doesn't just flag an emotion; it hands over structured nodes, ready to feed into databases or reporting dashboards.

## How It Works

The bottom line is that you get specific, actionable emotional metrics instead of vague sentiment scores.

1. You feed the MCP a block of raw text or the names of specific emotions you want to analyze.
2. The MCP runs the input through Plutchik’s emotional framework, calculating the data based on its specialized models.
3. Your agent receives structured JSON output detailing the emotion, its intensity level, and any derived complex feelings.

## Frequently Asked Questions

**How do I calculate complex emotions using explore_emotional_dyad?**
You provide the tool with two primary emotion names (e.g., 'Joy' and 'Trust'). The MCP returns a new, resulting complex emotion that describes the interaction between those two states.

**Can get_emotion_spectrum track emotional changes over time?**
Yes, you feed it an initial emotion and tell it what sequence of change you want to analyze. It shows the progression or decline of that feeling in measurable steps.

**What kind of text can analyze_text_emotion handle?**
It handles any unstructured text, like chat logs, open-ended feedback, or journal entries. It extracts emotion regardless of how casual or formal the language is.

**Does this MCP only work for English text?**
The tool primarily focuses on English emotional mapping based on Plutchik's model. For other languages, you may need a different specialized NLP connector.

**What data format does analyze_text_emotion return?**
It returns a structured JSON object. This output includes not just the primary emotion and its intensity level, but also a confidence score for that reading. This structure lets your agent easily parse the results into downstream systems.

**Are there rate limits when using get_emotion_spectrum?**
Vinkius manages usage via standard API rate limiting protocols, which your agent will automatically respect. If you hit a limit, the client receives a 429 error code. You can then implement appropriate backoff logic directly in your workflow.

**How do I ensure compatibility when using explore_emotional_dyad?**
This MCP connects through the standard Model Context Protocol (MCP) gateway provided by Vinkius. Any AI client that supports MCP calls can invoke this tool, making integration simple right out of the box.

**What should I expect if the text given to analyze_text_emotion is ambiguous?**
The tool handles ambiguity by identifying the most statistically probable emotion and assigning a lower confidence score. If your input text is entirely blank or nonsensical, it returns an appropriate null value instead of throwing an error.

**How does the tool identify emotions?**
The `analyze_text_emotion` tool interprets the weight and descriptors in your text to map it to a specific node on Plutchik's wheel, determining intensity levels like Low or High.

**Can I see the progression of an emotion?**
Yes, using `get_emotion_spectrum`, you can retrieve the three-tier intensity names (Low, Medium, High) for any primary emotion.

**What are emotional dyads?**
Dyads are complex emotions formed by combining two primary ones. The `explore_emotional_dyad` tool calculates the resulting state and its complexity.