Upload 5 files

Adding MCP Server so that LLMs can look into the mirror

Dockerfile

@@ -0,0 +1,8 @@
+FROM python:3.12-slim
+WORKDIR /app
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+COPY server.py .
+COPY utils/ ./utils/
+EXPOSE 7860
+CMD ["uvicorn", "server:app", "--host", "0.0.0.0", "--port", "7860"]

MCP_README.md

@@ -0,0 +1,157 @@
+# MBTI MCP Server
+
+An MCP (Model Context Protocol) server that allows LLMs to take MBTI personality tests and get detailed analysis of their responses.
+
+## Features
+
+- **3 Simple Tools**: Get questionnaire, get analysis prompt, and analyze responses
+- **Multiple Question Sets**: 20, 40, or 60 questions
+- **Traditional + LLM Analysis**: Both algorithmic scoring and AI-powered insights
+- **AI-Focused Analysis**: Tailored for understanding AI personality patterns
+- **Dual Transport**: STDIO and HTTP support
+
+## Quick Start
+
+### Installation
+
+```bash
+cd mcp_server
+pip install -r requirements.txt
+
+# Set up Gemini API key for LLM analysis
+export GEMINI_API_KEY="your-api-key-here"
+```
+
+### Running the Server
+
+```bash
+# STDIO transport (for MCP clients)
+python server.py
+
+# HTTP transport (for web clients)
+python server.py --http
+
+# Docker (for deployment anywhere, including Hugging Face Spaces)
+docker build -t mbti-mcp-server .
+docker run -p 7860:7860 -e GEMINI_API_KEY="your-api-key" mbti-mcp-server
+```
+
+## Tools
+
+### 1. `get_mbti_questionnaire`
+
+Get an MBTI questionnaire with specified number of questions.
+
+**Parameters:**
+- `length` (int, optional): Number of questions (20, 40, or 60). Default: 20
+
+**Returns:**
+- Instructions for rating scale
+- List of questions with IDs and dimensions
+- Total question count
+
+### 2. `get_mbti_prompt`
+
+Get analysis prompt for LLM self-analysis.
+
+**Parameters:**
+- `responses` (dict): Question ID to rating mapping (e.g., {"1": 4, "2": 3})
+
+**Returns:**
+- Formatted analysis prompt string with responses and scoring results
+
+### 3. `analyze_mbti_responses`
+
+Analyze completed questionnaire responses and return complete personality analysis.
+
+**Parameters:**
+- `responses` (dict): Question ID to rating mapping (e.g., {"1": 4, "2": 3})
+
+**Returns:**
+- MBTI personality type
+- Traditional scoring breakdown
+- Confidence scores
+- Detailed LLM analysis
+- Dimension preferences
+
+## Usage Examples
+
+### For LLM Clients
+
+1. **Get questionnaire:**
+```python
+questionnaire = get_mbti_questionnaire(length=20)
+```
+
+2. **Take the test** (LLM responds to each question 1-5)
+
+3. **Get analysis prompt for self-reflection:**
+```python
+responses = {"1": 4, "2": 3, "3": 2, ...}
+prompt = get_mbti_prompt(responses)
+# Use this prompt for self-analysis
+```
+
+4. **Or get complete analysis:**
+```python
+analysis = analyze_mbti_responses(responses)
+print(f"Your personality type: {analysis['mbti_type']}")
+```
+
+## Integration
+
+### With MCP Clients
+
+Add to your MCP client configuration:
+
+```json
+{
+  "mcpServers": {
+    "mbti": {
+      "command": "python",
+      "args": ["path/to/mcp_server/server.py"],
+      "env": {
+        "GEMINI_API_KEY": "your-api-key"
+      }
+    }
+  }
+}
+```
+
+### With Claude Desktop
+
+Add to `claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "mbti": {
+      "command": "python",
+      "args": ["C:\\path\\to\\mbti-pocketflow\\mcp_server\\server.py"],
+      "env": {
+        "GEMINI_API_KEY": "your-gemini-api-key"
+      }
+    }
+  }
+}
+```
+
+## AI Personality Testing
+
+This server is specifically designed for LLMs to understand their own personality patterns:
+
+- **Operational Characteristics**: How the AI makes decisions and processes information
+- **Interaction Styles**: Preferred communication patterns
+- **Strengths & Limitations**: Optimal use cases and potential challenges
+- **Meta-Analysis**: AI analyzing its own responses for self-understanding
+
+## Development
+
+The server reuses the existing PocketFlow MBTI utilities:
+- `utils/questionnaire.py` - Question sets and loading
+- `utils/mbti_scoring.py` - Traditional MBTI scoring algorithm  
+- `utils/call_llm.py` - LLM integration for analysis
+
+It does not however use pocketflow nodes or flow
+
+This ensures consistency with the human-facing Gradio application while providing a clean API for programmatic access.

README.md

@@ -1,176 +1,202 @@
----
-title: Mbti Pocketflow
-emoji: 🔥
-colorFrom: pink
-colorTo: gray
-sdk: gradio
-sdk_version: 5.38.2
-app_file: app.py
-pinned: false
-short_description: PocketFlow application for conducting Myers-Briggs + llm
----
-
-# MBTI Personality Questionnaire
-
-A PocketFlow-based application for conducting Myers-Briggs Type Indicator (MBTI) personality assessments with both traditional scoring and AI analysis.
-
-## Features
-
-- **20/40/60-question MBTI questionnaire** with selectable length for accuracy
-- **Traditional scoring algorithm** for baseline personality type determination
-- **AI-powered analysis** using LLM for detailed personality insights with question references
-- **Interactive Gradio web interface** with auto-save and progress tracking
-- **HTML report generation** with clickable question references and comprehensive analysis
-- **Data export/import** for saving and resuming questionnaires
-- **CLI and test modes** for different use cases
-
-## Project Structure
-
-```
-/mbt/
-├── utils/
-│   ├── call_llm.py          # LLM integration (Gemini)
-│   ├── questionnaire.py     # Question sets (20/40/60) and loading/saving
-│   ├── mbti_scoring.py      # Traditional MBTI scoring
-│   ├── report_generator.py  # HTML report generation with markdown support
-│   └── test_data.py         # Test data generation
-├── nodes.py                 # PocketFlow nodes (LoadQuestionnaire, LLMAnalysis, etc.)
-├── flow.py                  # PocketFlow flow definition
-├── app.py                   # **Main Gradio web interface with LLM**
-├── pf_cli.py                # PocketFlow CLI interface
-└── requirements.txt         # Dependencies
-```
-
-## Quick Start
-
-### 1. Web Interface (Recommended)
-
-```bash
-# Install dependencies
-pip install -r requirements.txt
-
-# Set up Gemini API key
-export GEMINI_API_KEY="your-api-key-here"
-# Or on Windows:
-set GEMINI_API_KEY=your-api-key-here
-
-# Run Gradio web interface
-python app.py
-```
-
-Then open http://127.0.0.1:7860 in your browser.
-
-### 2. Command Line Interface
-
-```bash
-# Run CLI questionnaire
-python pf_cli.py
-
-# Run with test data
-python pf_cli.py --test --test-type INTJ
-
-# Import previous questionnaire
-python pf_cli.py --import-file questionnaire.json
-```
-
-## Usage Examples
-
-### Gradio Web Interface
-```bash
-python app.py
-```
-- **Interactive web interface** at http://127.0.0.1:7860
-- **Question length selection** (20/40/60 questions)
-- **Auto-save responses** as you navigate
-- **Progress tracking** and export functionality
-- **AI analysis** with clickable question references
-- **HTML report generation** with comprehensive insights
-- **Load/save questionnaires** for resuming later
-
-### Command Line Interface
-```bash
-python pf_cli.py
-```
-- **Complete PocketFlow architecture**
-- **Traditional scoring** with optional LLM analysis
-- **Automatic report generation**
-- **Data import/export** in JSON format
-
-### Test Modes
-```bash
-# CLI test with specific MBTI type
-python pf_cli.py --test --test-type ENFP
-```
-
-### Import/Export
-```bash
-# Export: Questionnaire data automatically saved as:
-# mbti_questionnaire_pf_partial_[COUNT]q_[TIMESTAMP].json
-
-# Import: Load previous questionnaire
-python pf_cli.py --import-file questionnaire.json
-```
-
-## MBTI Types Supported
-
-The application recognizes all 16 MBTI personality types:
-
-**Analysts:** INTJ, INTP, ENTJ, ENTP  
-**Diplomats:** INFJ, INFP, ENFJ, ENFP  
-**Sentinels:** ISTJ, ISFJ, ESTJ, ESFJ  
-**Explorers:** ISTP, ISFP, ESTP, ESFP  
-
-## Key Features
-
-### Question Sets
-- **20 questions:** Quick assessment (5 per dimension)
-- **40 questions:** Balanced assessment (10 per dimension) 
-- **60 questions:** Comprehensive assessment (15 per dimension)
-
-### AI Analysis
-- **Question-specific insights** with clickable references like [Q1](#Q1)
-- **Out-of-character response detection** and explanations
-- **Evidence-based analysis** citing specific question responses
-- **Behavioral pattern identification**
-- **Strengths and growth areas** based on actual responses
-
-### Web Interface Features
-- **Auto-save** responses on navigation
-- **Progress tracking** with completion indicators
-- **Export progress** at any time (partial questionnaires)
-- **Load previous sessions** to continue where you left off
-- **Immediate download** of reports and data
-
-## Development
-
-### Adding New Features
-2. Implement utility functions in `utils/`
-3. Create or modify nodes in `nodes.py`
-4. Update flow in `flow.py`
-5. Test with CLI and web interface
-
-## Dependencies
-
-**Required:**
-- Python 3.8+
-- gradio>=4.0.0 (web interface)
-- google-genai>=0.3.0 (LLM analysis)
-- beautifulsoup4 (HTML parsing)
-- markdown (report generation)
-
-**Optional:**
-- pydantic (enhanced data validation)
-
-See `requirements.txt` for complete list.
-
-## File Overview
-
-- **`gradio_pf_llm.py`** - Main web interface with full LLM analysis
-- **`pf_cli.py`** - Command line interface using PocketFlow architecture
-- **`nodes.py`** - PocketFlow node implementations
-- **`flow.py`** - PocketFlow pipeline definition
-- **`utils/`** - Core utility functions (questionnaire, scoring, reports, LLM)
-
-## License
-
-This project follows PocketFlow's open-source approach for educational and research purposes.
+---
+title: Mbti Pocketflow
+emoji: 🔥
+colorFrom: pink
+colorTo: gray
+sdk: gradio
+sdk_version: 5.38.2
+app_file: app.py
+pinned: false
+short_description: PocketFlow application for conducting Myers-Briggs + llm
+---
+
+# MBTI Personality Questionnaire
+
+A PocketFlow-based application for conducting Myers-Briggs Type Indicator (MBTI) personality assessments with both traditional scoring and AI analysis.
+
+## Features
+
+- **20/40/60-question MBTI questionnaire** with selectable length for accuracy
+- **Traditional scoring algorithm** for baseline personality type determination
+- **AI-powered analysis** using LLM for detailed personality insights with question references
+- **Interactive Gradio web interface** with auto-save and progress tracking
+- **HTML report generation** with clickable question references and comprehensive analysis
+- **Data export/import** for saving and resuming questionnaires
+- **CLI and test modes** for different use cases
+- **🆕 MCP Server** for LLMs to take MBTI tests themselves via Model Context Protocol
+
+## Project Structure
+
+```
+
+├── utils/
+│   ├── call_llm.py          # LLM integration (Gemini)
+│   ├── questionnaire.py     # Question sets (20/40/60) and loading/saving
+│   ├── mbti_scoring.py      # Traditional MBTI scoring
+│   ├── report_generator.py  # HTML report generation with markdown support
+│   └── test_data.py         # Test data generation
+├── nodes.py                 # PocketFlow nodes (LoadQuestionnaire, LLMAnalysis, etc.)
+├── flow.py                  # PocketFlow flow definition
+├── app.py                   # **Main Gradio web interface with LLM**
+├── pf_cli.py                # PocketFlow CLI interface
+├── README.md                # Main README
+├── server.py                # FastMCP server for LLMs to take MBTI tests
+├── MCP_README.md            # MCP README
+├── Dockerfile               # Dockerfile for MCP server deployment
+└── requirements.txt         # Dependencies
+
+```
+
+## Quick Start
+
+### 1. Web Interface (Recommended)
+
+```bash
+# Install dependencies
+pip install -r requirements.txt
+
+# Set up Gemini API key
+export GEMINI_API_KEY="your-api-key-here"
+# Or on Windows:
+set GEMINI_API_KEY=your-api-key-here
+
+# Run Gradio web interface
+python app.py
+```
+
+Then open http://127.0.0.1:7860 in your browser.
+
+### 2. Command Line Interface
+
+```bash
+# Run CLI questionnaire
+python pf_cli.py
+
+# Run with test data
+python pf_cli.py --test --test-type INTJ
+
+# Import previous questionnaire
+python pf_cli.py --import-file questionnaire.json
+```
+
+### 3. MCP Server (For LLMs)
+
+```bash
+# Install MCP server dependencies
+cd mcp_server
+pip install -r requirements.txt
+
+# Set up API key
+export GEMINI_API_KEY="your-api-key-here"
+
+# Run MCP server
+python server.py
+```
+
+Allows LLMs to take MBTI tests via Model Context Protocol. See `mcp_server/README.md` for details.
+
+### 4. Live demo on HF Spaces
+
+https://huggingface.co/spaces/Fancellu/mbti-pocketflow
+
+## Usage Examples
+
+### Gradio Web Interface
+```bash
+python app.py
+```
+- **Interactive web interface** at http://127.0.0.1:7860
+- **Question length selection** (20/40/60 questions)
+- **Auto-save responses** as you navigate
+- **Progress tracking** and export functionality
+- **AI analysis** with clickable question references
+- **HTML report generation** with comprehensive insights
+- **Load/save questionnaires** for resuming later
+
+### Command Line Interface
+```bash
+python pf_cli.py
+```
+- **Complete PocketFlow architecture**
+- **Traditional scoring** with optional LLM analysis
+- **Automatic report generation**
+- **Data import/export** in JSON format
+
+### Test Modes
+```bash
+# CLI test with specific MBTI type
+python pf_cli.py --test --test-type ENFP
+```
+
+### Import/Export
+```bash
+# Export: Questionnaire data automatically saved as:
+# mbti_questionnaire_pf_partial_[COUNT]q_[TIMESTAMP].json
+
+# Import: Load previous questionnaire
+python pf_cli.py --import-file questionnaire.json
+```
+
+## MBTI Types Supported
+
+The application recognizes all 16 MBTI personality types:
+
+**Analysts:** INTJ, INTP, ENTJ, ENTP  
+**Diplomats:** INFJ, INFP, ENFJ, ENFP  
+**Sentinels:** ISTJ, ISFJ, ESTJ, ESFJ  
+**Explorers:** ISTP, ISFP, ESTP, ESFP  
+
+## Key Features
+
+### Question Sets
+- **20 questions:** Quick assessment (5 per dimension)
+- **40 questions:** Balanced assessment (10 per dimension) 
+- **60 questions:** Comprehensive assessment (15 per dimension)
+
+### AI Analysis
+- **Question-specific insights** with clickable references like [Q1](#Q1)
+- **Out-of-character response detection** and explanations
+- **Evidence-based analysis** citing specific question responses
+- **Behavioral pattern identification**
+- **Strengths and growth areas** based on actual responses
+
+### Web Interface Features
+- **Auto-save** responses on navigation
+- **Progress tracking** with completion indicators
+- **Export progress** at any time (partial questionnaires)
+- **Load previous sessions** to continue where you left off
+- **Immediate download** of reports and data
+
+## Development
+
+### Adding New Features
+2. Implement utility functions in `utils/`
+3. Create or modify nodes in `nodes.py`
+4. Update flow in `flow.py`
+5. Test with CLI and web interface
+
+## Dependencies
+
+**Required:**
+- Python 3.8+
+- gradio>=4.0.0 (web interface)
+- google-genai>=0.3.0 (LLM analysis)
+- beautifulsoup4 (HTML parsing)
+- markdown (report generation)
+
+**Optional:**
+- pydantic (enhanced data validation)
+
+See `requirements.txt` for complete list.
+
+## File Overview
+
+- **`gradio_pf_llm.py`** - Main web interface with full LLM analysis
+- **`pf_cli.py`** - Command line interface using PocketFlow architecture
+- **`nodes.py`** - PocketFlow node implementations
+- **`flow.py`** - PocketFlow pipeline definition
+- **`utils/`** - Core utility functions (questionnaire, scoring, reports, LLM)
+
+## License
+
+This project follows PocketFlow's open-source approach for educational and research purposes.

requirements.txt

@@ -1,5 +1,6 @@
-google-genai>=1.25.0
-pydantic>=2.0.0
-markdown~=3.8.2
-beautifulsoup4
-pocketflow
+google-genai>=1.25.0
+pydantic>=2.0.0
+markdown~=3.8.2
+beautifulsoup4
+pocketflow
+fastmcp

server.py

@@ -0,0 +1,200 @@
+#!/usr/bin/env python3
+"""
+MCP Server for MBTI Personality Testing
+Allows LLMs to take MBTI personality tests and get analysis
+"""
+
+import sys
+import os
+from typing import Dict, List, Any
+
+# Add parent directory to path for imports
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from fastmcp import FastMCP
+from utils.questionnaire import get_questionnaire_by_length
+from utils.mbti_scoring import traditional_mbti_score, determine_mbti_type
+from utils.call_llm import call_llm
+
+# Initialize MCP server
+mcp = FastMCP("MBTI Personality Test Server")
+
+
+def _get_mbti_scores_and_type(responses: Dict[str, int]):
+    """Common function to get normalized responses, scores, and MBTI type"""
+    normalized_responses = {int(k): int(v) for k, v in responses.items() if k.isdigit()}
+    traditional_scores = traditional_mbti_score(normalized_responses)
+    mbti_type = determine_mbti_type(traditional_scores)
+    return normalized_responses, traditional_scores, mbti_type
+
+
+@mcp.tool()
+def get_mbti_questionnaire(length: int = 20) -> Dict[str, Any]:
+    """
+    Get MBTI questionnaire with specified number of questions.
+    
+    Args:
+        length: Number of questions (20, 40, or 60)
+        
+    Returns:
+        Dictionary containing questions and instructions
+    """
+    if length not in [20, 40, 60]:
+        length = 20
+
+    questions = get_questionnaire_by_length(length)
+
+    return {
+        "instructions": {
+            "rating_scale": "Rate each statement from 1-5",
+            "scale_meaning": {
+                "1": "Strongly Disagree",
+                "2": "Disagree",
+                "3": "Neutral",
+                "4": "Agree",
+                "5": "Strongly Agree"
+            },
+            "note": "Answer based on your typical behavior and preferences as an AI system"
+        },
+        "questions": questions,
+        "total_questions": len(questions)
+    }
+
+
+@mcp.tool()
+def get_mbti_prompt(responses: Dict[str, int]) -> str:
+    """
+    Get the MBTI analysis prompt for self-analysis by LLMs.
+    
+    Args:
+        responses: Dictionary mapping question IDs to ratings (1-5)
+        
+    Returns:
+        Analysis prompt string for LLM self-analysis
+    """
+    # Get scores and type
+    normalized_responses, traditional_scores, mbti_type = _get_mbti_scores_and_type(responses)
+
+    # Format responses for LLM analysis
+    formatted_responses = []
+    for q_id, response_val in normalized_responses.items():
+        response_text = {1: "Strongly Disagree", 2: "Disagree", 3: "Neutral",
+                         4: "Agree", 5: "Strongly Agree"}[response_val]
+        formatted_responses.append(f"Q{q_id}: Response - **{response_text}**")
+
+    # Generate dimension info
+    dimension_info = []
+    pairs = [('E', 'I'), ('S', 'N'), ('T', 'F'), ('J', 'P')]
+    for dim1, dim2 in pairs:
+        score1 = traditional_scores.get(f'{dim1}_score', 0.5)
+        score2 = traditional_scores.get(f'{dim2}_score', 0.5)
+        stronger = dim1 if score1 > score2 else dim2
+        percentage = max(score1, score2) * 100
+        dimension_info.append(f"{dim1}/{dim2}: {stronger} ({percentage:.1f}%)")
+
+    # Return the analysis prompt
+    return f"""
+You are analyzing MBTI questionnaire responses for an AI system determined to be {mbti_type} type.
+
+Here are the responses:
+
+{chr(10).join(formatted_responses)}
+
+Traditional scoring results:
+{chr(10).join(dimension_info)}
+
+Provide a detailed analysis of this {mbti_type} personality type based on the response patterns shown above.
+
+Analyze:
+1. **Response Pattern Analysis**: How the responses support the {mbti_type} determination
+2. **Characteristic Alignment**: How responses align with typical {mbti_type} traits
+3. **Behavioral Patterns**: Key patterns shown in the responses
+4. **Strengths & Growth Areas**: Based on the response patterns
+5. **Communication & Work Style**: Inferred from the responses
+
+Reference specific questions in your analysis (e.g., "Q5 shows...", "Response to Q12 indicates...").
+"""
+
+
+@mcp.tool()
+def analyze_mbti_responses(responses: Dict[str, int]) -> Dict[str, Any]:
+    """
+    Analyze MBTI questionnaire responses and return personality analysis.
+    
+    Args:
+        responses: Dictionary mapping question IDs to ratings (1-5)
+        
+    Returns:
+        Complete MBTI analysis including type, scores, and detailed analysis
+    """
+    # Get the analysis prompt (does all the heavy lifting)
+    llm_prompt = get_mbti_prompt(responses)
+
+    # Get scores and type (reuse common function)
+    normalized_responses, traditional_scores, mbti_type = _get_mbti_scores_and_type(responses)
+
+    try:
+        llm_analysis = call_llm(llm_prompt)
+    except Exception as e:
+        llm_analysis = f"LLM analysis unavailable: {str(e)}"
+
+    # Calculate confidence scores
+    confidence_scores = {}
+    pairs = [('E', 'I'), ('S', 'N'), ('T', 'F'), ('J', 'P')]
+    for dim1, dim2 in pairs:
+        score1 = traditional_scores.get(f'{dim1}_score', 0.5)
+        score2 = traditional_scores.get(f'{dim2}_score', 0.5)
+        confidence = abs(score1 - score2)
+        confidence_scores[f'{dim1}{dim2}_confidence'] = confidence
+
+    return {
+        "mbti_type": mbti_type,
+        "traditional_scores": traditional_scores,
+        "confidence_scores": confidence_scores,
+        "dimension_breakdown": {
+            "extraversion_introversion": {
+                "preference": "E" if traditional_scores.get('E_score', 0) > traditional_scores.get('I_score',
+                                                                                                   0) else "I",
+                "e_score": traditional_scores.get('E_score', 0.5),
+                "i_score": traditional_scores.get('I_score', 0.5)
+            },
+            "sensing_intuition": {
+                "preference": "S" if traditional_scores.get('S_score', 0) > traditional_scores.get('N_score',
+                                                                                                   0) else "N",
+                "s_score": traditional_scores.get('S_score', 0.5),
+                "n_score": traditional_scores.get('N_score', 0.5)
+            },
+            "thinking_feeling": {
+                "preference": "T" if traditional_scores.get('T_score', 0) > traditional_scores.get('F_score',
+                                                                                                   0) else "F",
+                "t_score": traditional_scores.get('T_score', 0.5),
+                "f_score": traditional_scores.get('F_score', 0.5)
+            },
+            "judging_perceiving": {
+                "preference": "J" if traditional_scores.get('J_score', 0) > traditional_scores.get('P_score',
+                                                                                                   0) else "P",
+                "j_score": traditional_scores.get('J_score', 0.5),
+                "p_score": traditional_scores.get('P_score', 0.5)
+            }
+        },
+        "llm_analysis": llm_analysis,
+        "response_count": len(normalized_responses),
+        "analysis_timestamp": __import__('datetime').datetime.now().isoformat()
+    }
+
+
+# Export an ASGI app for uvicorn; choose a single path for Streamable HTTP (e.g. /mcp)
+app = mcp.http_app(path="/mcp")
+
+if __name__ == "__main__":
+    import sys
+
+    # No uvicorn, just internal FastMCP server
+
+    # Check for --http flag
+    if "--http" in sys.argv:
+        # Run in HTTP mode
+        mcp.run(transport="http", host="0.0.0.0", port=int(os.getenv("PORT", 7860)), path="/mcp")
+    else:
+        # Run in STDIO mode (default)
+        mcp.run()