Add initial implementation of text counting features and configuration files

.gitignore

@@ -0,0 +1,7 @@
+.env
+node_modules/
+dist/
+.vscode/
+.DS_Store
+.venv
+__pycache__/

README.md

@@ -1,13 +1,192 @@
----
-title: Text Counting
-emoji: 💻
-colorFrom: indigo
-colorTo: pink
-sdk: gradio
-sdk_version: 5.49.1
-app_file: app.py
-pinned: false
-short_description: MCP server for comprehensive text analysis and counting oper
+# Text Counting MCP Server
+
+A comprehensive text analysis and counting operations server built with Gradio, featuring both a web interface and MCP (Model Context Protocol) server capabilities.
+
+## Features
+
+This application provides 13 different text counting and analysis functions:
+
+- **Letter Counter**: Count alphabetic characters in text
+- **Word Counter**: Count words in sentences or paragraphs  
+- **Sentence Counter**: Count sentences using multiple punctuation marks (., !, ?)
+- **Paragraph Counter**: Count paragraphs separated by double line breaks
+- **Vowel Counter**: Count vowel characters (a, e, i, o, u)
+- **Consonant Counter**: Count consonant characters
+- **Special Character Counter**: Count special symbols and punctuation
+- **Digit Counter**: Count numeric digits (0-9)
+- **Whitespace Counter**: Count spaces, tabs, and line breaks
+- **Uppercase Letter Counter**: Count capital letters
+- **Lowercase Letter Counter**: Count lowercase letters
+- **Unique Word Counter**: Count distinct words in text
+- **Syllable Counter**: Estimate syllables with enhanced algorithm
+
+## Quick Start
+
+### Prerequisites
+
+- Python 3.8+
+- pip package manager
+
+### Installation
+
+1. **Clone or download the project**
+   ```bash
+   git clone <repository-url>
+   cd hugging-face
+   ```
+
+2. **Create and activate virtual environment** (recommended)
+   ```bash
+   python -m venv .venv
+   
+   # On Windows:
+   .venv\Scripts\activate
+   
+   # On macOS/Linux:
+   source .venv/bin/activate
+   ```
+
+3. **Install dependencies**
+   ```bash
+   pip install gradio
+   ```
+
+### Running the Application
+
+**Web Interface Mode:**
+```bash
+python mcp_server.py
+```
+
+The application will launch at `http://localhost:7860` with a tabbed interface for each counting function.
+
+**MCP Server Mode:**
+```bash
+# Enable MCP server functionality by setting mcp_server=True in the code
+python mcp_server.py
+```
+
+## Usage Examples
+
+### Web Interface
+1. Navigate to the launched URL (typically `http://localhost:7860`)
+2. Select the desired counting function from the tabs
+3. Enter your text in the input field
+4. View the results instantly
+
+### Python API
+```python
+from mcp_server import count_letters, count_words, count_syllables
+
+# Count letters
+result = count_letters("Hello World!")  # Returns: 10
+
+# Count words  
+result = count_words("This is a test sentence.")  # Returns: 5
+
+# Count syllables
+result = count_syllables("beautiful")  # Returns: 3
+```
+
+## Project Structure
+
+```
+hugging-face/
+├── mcp_server.py          # Main application with Gradio interface
+├── mcp.json              # MCP server configuration
+├── agent.json            # Agent configuration
+├── README.md             # This file
+├── .gitignore           # Git ignore rules
+└── .venv/               # Virtual environment (created after setup)
+```
+
+## Configuration
+
+### MCP Server Configuration
+The `mcp.json` file defines the MCP server capabilities and tool definitions. It includes:
+- Server metadata (name, version, description)
+- Tool definitions with parameter schemas
+- Capability declarations
+
+### Environment Setup
+- Python virtual environment in `.venv/`
+- Gradio for web interface
+- MCP server capabilities built into Python application
+
+## Function Details
+
+### Enhanced Features
+
+1. **Robust Input Handling**: All functions accept any input type and convert to string
+2. **Improved Algorithms**: 
+   - Sentence counting uses regex for multiple punctuation marks
+   - Syllable counting handles silent 'e' and edge cases
+3. **Error Handling**: Functions gracefully handle empty inputs and special cases
+4. **Type Safety**: Full type hints and comprehensive docstrings
+
+### Algorithm Highlights
+
+- **Syllable Counter**: Uses vowel grouping with silent 'e' detection
+- **Sentence Counter**: Regex-based splitting on `.!?` patterns
+- **Letter Counter**: Only counts alphabetic characters (excludes numbers/symbols)
+
+## Development
+
+### Code Quality Features
+- Complete type hints for all functions
+- Comprehensive docstrings with Args: blocks  
+- Input validation and type conversion
+- Error handling for edge cases
+- Consistent code formatting
+
+### Adding New Functions
+1. Define the function with proper type hints
+2. Add comprehensive docstring with Args: and Returns: sections
+3. Include input validation (`str(input)` conversion)
+4. Add the function to the Gradio interface
+5. Update MCP configuration if needed
+
+## Contributing
+
+1. Fork the repository
+2. Create a feature branch (`git checkout -b feature/new-counter`)
+3. Make your changes following the code quality standards
+4. Add tests if applicable
+5. Submit a pull request
+
+## License
+
+This project is licensed under the ISC License - see the LICENSE file for details.
+
+## Troubleshooting
+
+### Common Issues
+
+**"ModuleNotFoundError: No module named 'gradio'"**
+```bash
+pip install gradio
+```
+
+**"JSON-RPC error: Not Acceptable: Client must accept text/event-stream"**
+- This occurs when `mcp_server=True` is enabled but the client doesn't support event streams
+- For web interface only, ensure `mcp_server=False` or remove the parameter
+
+**Virtual Environment Issues**
+```bash
+# Recreate virtual environment
+rm -rf .venv
+python -m venv .venv
+.venv\Scripts\activate  # Windows
+pip install gradio
+```
+
+## Performance
+
+- Lightweight algorithms optimized for text processing
+- Efficient character iteration using generator expressions
+- Memory-efficient for large text inputs
+- Real-time processing suitable for interactive use
+
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+**Built using Python, Gradio, and MCP**

agent.json

@@ -0,0 +1,16 @@
+{
+    "name": "text-counting-agent",
+    "description": "AI agent with text counting and analysis capabilities",
+    "model": "Qwen/Qwen2.5-72B-Instruct",
+    "provider": "nebius",
+    "system_prompt": "You are a helpful AI assistant specialized in text analysis and counting operations. Use the available text counting tools to provide accurate analysis of text content including letters, words, sentences, paragraphs, vowels, consonants, and other text elements.",
+    "servers": [
+        {
+            "name": "text-counting-server",
+            "type": "stdio",
+            "command": "D:/source/hugging-face/.venv/Scripts/python.exe",
+            "args": ["mcp_server.py"],
+            "cwd": "D:/source/hugging-face"
+        }
+    ]
+}

mcp.json

@@ -0,0 +1,149 @@
+{
+  "name": "text-counting-mcp-server",
+  "version": "1.0.0",
+  "description": "MCP server for comprehensive text analysis and counting operations",
+  "main": "mcp_server.py",
+  "type": "mcp-server",
+  "tools": [
+    {
+      "name": "count_letters",
+      "description": "Count the number of letters in a word or text",
+      "parameters": {
+        "text": {
+          "type": "string",
+          "description": "The text to count letters in"
+        }
+      }
+    },
+    {
+      "name": "count_words",
+      "description": "Count the number of words in a sentence or text",
+      "parameters": {
+        "text": {
+          "type": "string",
+          "description": "The text to count words in"
+        }
+      }
+    },
+    {
+      "name": "count_sentences",
+      "description": "Count the number of sentences in a paragraph or text",
+      "parameters": {
+        "text": {
+          "type": "string",
+          "description": "The text to count sentences in"
+        }
+      }
+    },
+    {
+      "name": "count_paragraphs",
+      "description": "Count the number of paragraphs in a text",
+      "parameters": {
+        "text": {
+          "type": "string",
+          "description": "The text to count paragraphs in"
+        }
+      }
+    },
+    {
+      "name": "count_vowels",
+      "description": "Count the number of vowels in a word or text",
+      "parameters": {
+        "text": {
+          "type": "string",
+          "description": "The text to count vowels in"
+        }
+      }
+    },
+    {
+      "name": "count_consonants",
+      "description": "Count the number of consonants in a word or text",
+      "parameters": {
+        "text": {
+          "type": "string",
+          "description": "The text to count consonants in"
+        }
+      }
+    },
+    {
+      "name": "count_special_characters",
+      "description": "Count the number of special characters in a text",
+      "parameters": {
+        "text": {
+          "type": "string",
+          "description": "The text to count special characters in"
+        }
+      }
+    },
+    {
+      "name": "count_digits",
+      "description": "Count the number of digits in a text",
+      "parameters": {
+        "text": {
+          "type": "string",
+          "description": "The text to count digits in"
+        }
+      }
+    },
+    {
+      "name": "count_whitespaces",
+      "description": "Count the number of whitespace characters in a text",
+      "parameters": {
+        "text": {
+          "type": "string",
+          "description": "The text to count whitespaces in"
+        }
+      }
+    },
+    {
+      "name": "count_uppercase_letters",
+      "description": "Count the number of uppercase letters in a text",
+      "parameters": {
+        "text": {
+          "type": "string",
+          "description": "The text to count uppercase letters in"
+        }
+      }
+    },
+    {
+      "name": "count_lowercase_letters",
+      "description": "Count the number of lowercase letters in a text",
+      "parameters": {
+        "text": {
+          "type": "string",
+          "description": "The text to count lowercase letters in"
+        }
+      }
+    },
+    {
+      "name": "count_unique_words",
+      "description": "Count the number of unique words in a sentence or text",
+      "parameters": {
+        "text": {
+          "type": "string",
+          "description": "The text to count unique words in"
+        }
+      }
+    },
+    {
+      "name": "count_syllables",
+      "description": "Count the number of syllables in a word",
+      "parameters": {
+        "text": {
+          "type": "string",
+          "description": "The word to count syllables in"
+        }
+      }
+    }
+  ],
+  "capabilities": {
+    "text_analysis": true,
+    "counting_operations": true,
+    "linguistic_analysis": true
+  },
+  "config": {
+    "language": "python",
+    "runtime": "python3.12",
+    "entry_point": "mcp_server.py"
+  }
+}

mcp_server.py

@@ -0,0 +1,225 @@
+import gradio as gr
+
+"""Module for counting various text elements."""
+
+def count_letters(word: str) -> int:
+    """Count the number of letters in a word.
+    
+    Args:
+        word: The word or text to count letters in.
+        
+    Returns:
+        The number of alphabetic characters in the input.
+    """
+    word = str(word)  # Ensure string input
+    return sum(1 for char in word if char.isalpha())
+
+def count_words(sentence: str) -> int:
+    """Count the number of words in a sentence.
+    
+    Args:
+        sentence: The sentence or text to count words in.
+        
+    Returns:
+        The number of words in the input text.
+    """
+    sentence = str(sentence)  # Ensure string input
+    words = sentence.split()
+    return len(words)
+
+def count_sentences(paragraph: str) -> int:
+    """Count the number of sentences in a paragraph.
+    
+    Args:
+        paragraph: The paragraph or text to count sentences in.
+        
+    Returns:
+        The number of sentences in the input text.
+    """
+    paragraph = str(paragraph)  # Ensure string input
+    # Split on multiple sentence terminators
+    import re
+    sentences = re.split(r'[.!?]+', paragraph)
+    return len([s for s in sentences if s.strip()])
+
+def count_paragraphs(text: str) -> int:
+    """Count the number of paragraphs in a text.
+    
+    Args:
+        text: The text to count paragraphs in.
+        
+    Returns:
+        The number of paragraphs in the input text.
+    """
+    text = str(text)  # Ensure string input
+    paragraphs = text.split('\n\n')
+    return len([p for p in paragraphs if p.strip()])
+
+def count_vowels(word: str) -> int:
+    """Count the number of vowels in a word.
+    
+    Args:
+        word: The word or text to count vowels in.
+        
+    Returns:
+        The number of vowel characters in the input.
+    """
+    word = str(word)  # Ensure string input
+    vowels = 'aeiouAEIOU'
+    return sum(1 for char in word if char in vowels)
+
+def count_consonants(word: str) -> int:
+    """Count the number of consonants in a word.
+    
+    Args:
+        word: The word or text to count consonants in.
+        
+    Returns:
+        The number of consonant characters in the input.
+    """
+    word = str(word)  # Ensure string input
+    vowels = 'aeiouAEIOU'
+    return sum(1 for char in word if char.isalpha() and char not in vowels)
+
+def count_special_characters(text: str) -> int:
+    """Count the number of special characters in a text.
+    
+    Args:
+        text: The text to count special characters in.
+        
+    Returns:
+        The number of special characters in the input.
+    """
+    text = str(text)  # Ensure string input
+    special_characters = '!@#$%^&*()_+-=[]{}|;:\'",.<>?/`~'
+    return sum(1 for char in text if char in special_characters)
+
+def count_digits(text: str) -> int:
+    """Count the number of digits in a text.
+    
+    Args:
+        text: The text to count digits in.
+        
+    Returns:
+        The number of digit characters in the input.
+    """
+    text = str(text)  # Ensure string input
+    return sum(1 for char in text if char.isdigit())
+
+def count_whitespaces(text: str) -> int:
+    """Count the number of whitespace characters in a text.
+    
+    Args:
+        text: The text to count whitespace characters in.
+        
+    Returns:
+        The number of whitespace characters in the input.
+    """
+    text = str(text)  # Ensure string input
+    return sum(1 for char in text if char.isspace())
+
+def count_uppercase_letters(text: str) -> int:
+    """Count the number of uppercase letters in a text.
+    
+    Args:
+        text: The text to count uppercase letters in.
+        
+    Returns:
+        The number of uppercase letters in the input.
+    """
+    text = str(text)  # Ensure string input
+    return sum(1 for char in text if char.isupper())
+
+def count_lowercase_letters(text: str) -> int:
+    """Count the number of lowercase letters in a text.
+    
+    Args:
+        text: The text to count lowercase letters in.
+        
+    Returns:
+        The number of lowercase letters in the input.
+    """
+    text = str(text)  # Ensure string input
+    return sum(1 for char in text if char.islower())
+
+def count_unique_words(sentence: str) -> int:
+    """Count the number of unique words in a sentence.
+    
+    Args:
+        sentence: The sentence or text to count unique words in.
+        
+    Returns:
+        The number of unique words in the input.
+    """
+    sentence = str(sentence)  # Ensure string input
+    words = sentence.split()
+    unique_words = set(words)
+    return len(unique_words)
+
+def count_syllables(word: str) -> int:
+    """Count the number of syllables in a word.
+    
+    Args:
+        word: The word to count syllables in.
+        
+    Returns:
+        The estimated number of syllables in the word.
+    """
+    word = str(word).lower().strip()  # Ensure string input and normalize
+    if not word:
+        return 0
+    
+    vowels = 'aeiou'
+    count = 0
+    in_vowel_group = False
+    
+    for char in word:
+        if char in vowels:
+            if not in_vowel_group:
+                count += 1
+                in_vowel_group = True
+        else:
+            in_vowel_group = False
+    
+    # Handle silent 'e' at the end
+    if word.endswith('e') and count > 1:
+        count -= 1
+    
+    # Ensure at least one syllable for non-empty words
+    return max(1, count) if any(c.isalpha() for c in word) else 0
+
+
+# Create a standard Gradio interface to test the functions
+
+with gr.Blocks() as demo:
+    gr.Markdown("# Module for counting various text elements")
+    with gr.Tab("Letter Counter"):
+        gr.Interface(fn=count_letters, inputs="text", outputs="number")
+    with gr.Tab("Word Counter"):
+        gr.Interface(fn=count_words, inputs="text", outputs="number")
+    with gr.Tab("Sentence Counter"):
+        gr.Interface(fn=count_sentences, inputs="text", outputs="number")
+    with gr.Tab("Paragraph Counter"):
+        gr.Interface(fn=count_paragraphs, inputs="text", outputs="number")
+    with gr.Tab("Vowel Counter"):
+        gr.Interface(fn=count_vowels, inputs="text", outputs="number")
+    with gr.Tab("Consonant Counter"):
+        gr.Interface(fn=count_consonants, inputs="text", outputs="number")
+    with gr.Tab("Special Character Counter"):
+        gr.Interface(fn=count_special_characters, inputs="text", outputs="number")
+    with gr.Tab("Digit Counter"):
+        gr.Interface(fn=count_digits, inputs="text", outputs="number")
+    with gr.Tab("Whitespace Counter"):
+        gr.Interface(fn=count_whitespaces, inputs="text", outputs="number")
+    with gr.Tab("Uppercase Letter Counter"):
+        gr.Interface(fn=count_uppercase_letters, inputs="text", outputs="number")
+    with gr.Tab("Lowercase Letter Counter"):
+        gr.Interface(fn=count_lowercase_letters, inputs="text", outputs="number")
+    with gr.Tab("Unique Word Counter"):
+        gr.Interface(fn=count_unique_words, inputs="text", outputs="number")
+    with gr.Tab("Syllable Counter"):
+        gr.Interface(fn=count_syllables, inputs="text", outputs="number")
+
+if __name__ == "__main__":
+    demo.launch(mcp_server=True)
+