Content
# ChatExcel MCP Server - Enterprise Enhanced Edition v2.1.1
> **Latest Update (2025-06-19)**: pandas import issue completely fixed, project structure optimization completed, enterprise-level features fully ready
> 🚀 **Enterprise-grade Excel Intelligent Processing and Data Analysis MCP Server** - High-performance data processing solution based on FastMCP
**chatExcel-mcp** is an enterprise-grade Excel intelligent processing server based on MCP (Model Context Protocol), providing powerful Excel file analysis, data processing, formula calculation, and visualization capabilities.
[](https://python.org)
[](https://github.com/jlowin/fastmcp)
[](https://golang.org)
[](LICENSE)
[](pyproject.toml)
[](https://pypi.org/project/formulas/)
[](#-security-considerations)
[](#-performance-optimization)
[](#-ops-tools)
## 🚀 Core Features
### 📊 31 Professional MCP Tools
- **Data Reading and Metadata Analysis** (2 tools): Intelligent encoding detection, structural analysis
- **Data Processing and Execution** (9 tools): Secure code execution, parameter recommendation, template generation
- **Data Visualization** (3 tools): Interactive chart generation (Chart.js)
- **Data Validation and Quality Control** (12 tools): Multi-level quality checks, intelligent cleaning
- **Excel Formula Processing** (5 tools): Formula parsing, compilation, execution, validation
### 🏗️ Dual-Engine Architecture
- **Python Engine**: Traditional processing based on pandas/openpyxl, supporting complex data analysis
- **Go Engine**: High-performance concurrent processing, suitable for large-scale data processing (optional)
### 🧮 Excel Formula Engine (New)
- **Formula Parsing**: AST syntax analysis and security verification, supporting complex nested formulas
- **Formula Compilation**: Code generation and dependency analysis, optimizing execution performance
- **Formula Execution**: Secure execution environment and result verification, supporting contextual calculations
- **Dependency Analysis**: Dependency graph generation and loop detection, avoiding calculation deadlocks
- **Formula Validation**: Syntax checking and risk assessment, ensuring formula security
### 🔍 Data Quality Control (Enhanced)
- **Multi-level Quality Checks**: Comprehensive verification of data integrity, consistency, and accuracy
- **Intelligent Data Cleaning**: Automated data cleaning and format standardization
- **Batch Processing**: Parallel processing of multiple Excel files, improving processing efficiency
- **Advanced Extraction**: Multi-condition data extraction and content analysis
- **Intelligent Merging**: Multi-table data merging and configurable processing
- **Character Format Conversion**: Automated character format conversion and rule configuration
### 🛡️ Enterprise-Grade Security
- **Code Security**: AST analysis and function whitelisting, preventing malicious code execution
- **Execution Sandbox**: Isolated execution environment, protecting system security
- **Permission Control**: Fine-grained access control and operation auditing
- **Dependency Scanning**: Intelligent dependency analysis and security vulnerability detection
### ⚡ Performance Optimization
- **Intelligent Caching**: Multi-level caching strategies, reducing redundant calculations
- **Concurrent Processing**: Asynchronous task execution, improving processing speed
- **Memory Management**: Large file chunk processing, optimizing memory usage
- **Error Recovery**: Automatic retry mechanism and health monitoring
## 📋 Project Overview
ChatExcel MCP Server is a powerful Model Context Protocol (MCP) server designed specifically for Excel file processing, data analysis, and visualization. The project integrates the best data processing libraries from the Python ecosystem and provides high-performance Excel operation capabilities through the Go excelize library.
### 🎯 Core Features
- **31 Professional MCP Tools** - Covering the entire process of Excel data reading, processing, validation, visualization, formula calculation, and data quality control
- **Dual-Engine Architecture** - Python pandas + Go excelize hybrid processing engine
- **Excel Formula Engine** - Complete Excel formula parsing, compilation, and execution system based on the formulas library
- **Data Quality Control** - 7 professional data quality tools, supporting advanced data cleaning and validation
- **Intelligent Parameter Recommendation** - Automatically detects Excel file structure and recommends optimal reading parameters
- **Enterprise-Grade Security** - Multi-layer security mechanisms, code sandbox execution environment, formula security verification
- **Performance Optimization** - Caching mechanism, concurrent processing, memory optimization
- **Health Monitoring** - Complete service monitoring, logging, and error tracking
- **Visualization Support** - Interactive chart generation (Chart.js, Plotly, Matplotlib)
## 🛠️ Tool List
This project provides **31 professional MCP tools**, covering the complete lifecycle of Excel data processing, analysis, validation, formula calculation, and data quality control.
### 📊 Data Reading and Metadata Tools (4 tools)
| Tool Name | Description | Key Features |
|---------|----------|----------|
| `read_metadata` | CSV file metadata reading and intelligent analysis | Encoding detection, delimiter identification, data statistics |
| `read_excel_metadata` | Excel file metadata reading and integrity verification | Multi-worksheet analysis, intelligent encoding detection |
| `excel_read_enhanced` | Enhanced Excel reading tool | Go excelize integration, intelligent parameter recommendation |
| `excel_info_enhanced` | Enhanced Excel file information retrieval | Detailed file analysis, worksheet statistics |
### 🔧 Data Processing and Execution Tools (6 tools)
| Tool Name | Description | Key Features |
|---------|----------|----------|
| `run_excel_code` | Excel code execution engine | Secure sandbox, complex format parameter support, ✅ pandas import completely fixed |
| `run_code` | CSV code execution engine | Secure environment, pandas integration, ✅ enhanced execution environment |
| `excel_write_enhanced` | Enhanced Excel writing tool | Format optimization, style support |
| `excel_chart_enhanced` | Enhanced Excel chart generation | Multiple chart types, custom styles |
| `excel_performance_comparison` | Excel performance comparison analysis | Go vs Python performance testing |
| `batch_data_verification_tool` | Batch data verification tool | Concurrent processing, batch reports |
### 📈 Data Visualization Tools (3 tools)
| Tool Name | Description | Key Features |
|---------|----------|----------|
| `bar_chart_to_html` | Interactive bar chart generation | Chart.js, responsive design |
| `pie_chart_to_html` | Interactive pie chart generation | Animation effects, data labels |
| `line_chart_to_html` | Interactive line chart generation | Multi-dimensional data, trend analysis |
### 🔍 Data Validation and Quality Tools (3 tools)
| Tool Name | Description | Key Features |
|---------|----------|----------|
| `verify_data_integrity` | Data integrity verification and comparison approval | Multiple verification modes, detailed reports |
| `validate_data_quality` | Data quality verification and improvement suggestions | Quality scoring, optimization suggestions |
| `comprehensive_data_verification_tool` | Comprehensive data verification and approval tool | Comprehensive verification, quality assessment, comparison approval |
### 🤖 Intelligent Assistance Tools (3 tools)
| Tool Name | Description | Key Features |
|---------|----------|----------|
| `suggest_excel_read_parameters_tool` | Intelligent recommendation of Excel reading parameters | Structural analysis, parameter optimization |
| `detect_excel_file_structure_tool` | Excel file structure detection | Multi-level headers, data region identification |
| `create_excel_read_template_tool` | Excel reading code template generation | Intelligent templates, parameter configuration |
### 🧮 Excel Formula Processing Tools (5 tools)
| Tool Name | Description | Key Features |
|---------|----------|----------|
| `parse_formula` | Excel formula parser | AST parsing, syntax analysis, security verification |
| `compile_workbook` | Excel workbook compiler | Formula compilation, code generation, dependency analysis |
| `execute_formula` | Excel formula execution engine | Secure execution, context support, result verification |
| `analyze_dependencies` | Excel formula dependency analysis | Dependency graph generation, loop detection, impact analysis |
| `validate_formula` | Excel formula validator | Security checks, syntax verification, risk assessment |
### 🔍 Data Quality Control Tools (7 tools) - **New**
| Tool Name | Description | Key Features |
|---------|----------|----------|
| `enhanced_data_quality_check` | Enhanced data quality check | Multi-level quality checks, comprehensive reports |
| `extract_cell_content_advanced` | Advanced cell content extraction | Multi-type extraction, formatted content |
| `convert_character_formats` | Automated character format conversion | Batch conversion, rule configuration |
| `extract_multi_condition_data` | Multi-condition data extraction | Complex conditions, flexible filtering |
| `merge_multiple_tables` | Multi-table data merging | Intelligent merging, configurable processing |
| `clean_excel_data` | Excel data cleaning | Comprehensive cleaning, quality improvement |
| `batch_process_excel_files` | Batch Excel file processing | Parallel processing, unified configuration |
---
## 📋 Workflow User Manual - Complete Guide to 31 MCP Tools
This chapter categorizes and associates the 31 MCP tools according to the actual usage scenarios and the entire data processing workflow, providing a complete workflow user guide.
### 🎯 Data Processing Workflow Overview
```mermaid
flowchart TD
A[📁 Data Source] --> B[🔍 Data Exploration Phase]
B --> C[📊 Data Reading Phase]
C --> D[🔧 Data Processing Phase]
D --> E[✅ Data Validation Phase]
E --> F[📈 Data Visualization Phase]
F --> G[🧮 Formula Calculation Phase]
G --> H[🔍 Quality Control Phase]
H --> I[📤 Data Output Phase]
B --> B1[File Structure Detection]
B --> B2[Metadata Analysis]
B --> B3[Parameter Recommendation]
C --> C1[Intelligent Reading]
C --> C2[Encoding Detection]
C --> C3[Template Generation]
D --> D1[Code Execution]
D --> D2[Data Conversion]
D --> D3[Batch Processing]
E --> E1[Integrity Verification]
E --> E2[Quality Check]
E --> E3[Data Comparison]
F --> F1[Chart Generation]
F --> F2[Interactive Visualization]
F --> F3[Report Output]
G --> G1[Formula Parsing]
G --> G2[Formula Execution]
G --> G3[Dependency Analysis]
H --> H1[Data Cleaning]
H --> H2[Format Conversion]
H --> H3[Multi-Table Merging]
I --> I1[Excel Writing]
I --> I2[Chart Embedding]
I --> I3[Performance Comparison]
```
### 🚀 Phase 1: Data Exploration and Preparation (7 tools)
#### 📋 Use Case
When you get a new Excel file, you first need to understand the file structure, data characteristics, and the best way to read it.
#### 🛠️ Core Tool Combination
| Step | Tool Name | Purpose | Output Result |
|------|----------|----------|----------|
| 1️⃣ | `excel_info_enhanced` | Get basic file information | Worksheet list, file size, format information |
| 2️⃣ | `read_excel_metadata` | Deep metadata analysis | Data type, encoding format, statistical information |
| 3️⃣ | `detect_excel_file_structure_tool` | Intelligent structure detection | Header position, data area, merged cells |
| 4️⃣ | `suggest_excel_read_parameters_tool` | Intelligent parameter recommendation | Optimal reading parameter configuration |
| 5️⃣ | `create_excel_read_template_tool` | Generate reading template | Executable reading code template |
#### 💡 Workflow Example
```
```
### 📊 Phase 2: Data Reading and Loading (4 tools)
#### 📋 Use Case
Based on the analysis results of the exploration phase, perform efficient and accurate data reading operations.
#### 🛠️ Core Tool Combination
| Tool Name | Applicable Scenario | Core Advantages | Performance Characteristics |
|----------|----------|----------|----------|
| `excel_read_enhanced` | Standard Excel file reading | Go engine acceleration, intelligent parameters | High performance, large file support |
| `read_metadata` | CSV file metadata reading | Automatic encoding detection, delimiter identification | Lightweight, fast response |
| `read_excel_metadata` | Dedicated to Excel metadata | Multi-worksheet analysis, integrity verification | Comprehensive analysis, accurate and reliable |
| `excel_performance_comparison` | Performance benchmark testing | Python vs Go performance comparison | Performance optimization, engine selection |
#### 💡 Workflow Example
```
```
### 🔧 Phase 3: Data Processing and Transformation (6 tools)
#### 📋 Use Case
Clean, transform, calculate, and process the read data.
#### 🛠️ Core Tool Combination
| Processing Type | Tool Name | Description | Security Level |
|----------|----------|----------|----------|
| **Code Execution** | `run_excel_code` | Excel data code execution engine | 🔒 Sandbox isolation |
| **Code Execution** | `run_code` | CSV data code execution engine | 🔒 Secure environment |
| **Data Writing** | `excel_write_enhanced` | Enhanced Excel writing tool | ✅ Format optimization |
| **Chart Generation** | `excel_chart_enhanced` | Excel embedded chart generation | 📊 Multiple style support |
| **Batch Verification** | `batch_data_verification_tool` | Batch data verification processing | ⚡ Concurrent processing |
| **Performance Comparison** | `excel_performance_comparison` | Processing performance benchmark testing | 📈 Optimization suggestions |
#### 💡 Workflow Example
```
```
### ✅ Phase 4: Data Validation and Quality Control (10 tools)
#### 📋 Use Case
Ensuring data quality, integrity, and accuracy is a critical part of the data processing workflow.
#### 🛠️ Core Tool Combination
##### 🔍 Basic Validation Tools (3 tools)
| Tool Name | Verification Focus | Output Report |
|----------|----------|----------|
| `verify_data_integrity` | Data integrity, consistency verification | Detailed verification report, problem location |
| `validate_data_quality` | Data quality assessment, improvement suggestions | Quality score, optimization suggestions |
| `comprehensive_data_verification_tool` | Comprehensive verification, comprehensive assessment | Complete verification report, quality certification |
##### 🧹 Advanced Quality Control Tools (7 tools)
| Tool Name | Professional Field | Core Function |
|----------|----------|----------|
| `enhanced_data_quality_check` | Multi-level quality checks | In-depth quality analysis, comprehensive assessment |
| `extract_cell_content_advanced` | Content extraction analysis | Multi-type extraction, formatted processing |
| `convert_character_formats` | Character format standardization | Batch conversion, rule configuration |
| `extract_multi_condition_data` | Complex condition filtering | Multi-dimensional filtering, flexible configuration |
| `merge_multiple_tables` | Multi-table data integration | Intelligent merging, relationship processing |
| `clean_excel_data` | Data cleaning optimization | Comprehensive cleaning, quality improvement |
| `batch_process_excel_files` | Batch file processing | Parallel processing, unified standards |
#### 💡 Workflow Example
```
```
### 📈 Phase 5: Data Visualization and Reporting (3 tools)
#### 📋 Use Case
Convert processed data into intuitive charts and interactive visualization reports.
#### 🛠️ Core Tool Combination
| Chart Type | Tool Name | Applicable Scenario | Technical Features |
|----------|----------|----------|----------|
| **Bar Chart** | `bar_chart_to_html` | Categorical data comparison, trend analysis | Chart.js, responsive design |
| **Pie Chart** | `pie_chart_to_html` | Percentage analysis, composition display | Animation effects, data labels |
| **Line Chart** | `line_chart_to_html` | Time series, trend changes | Multi-dimensional data, interactive zooming |
#### 💡 Workflow Example
```
```
### 🧮 Phase 6: Excel Formula Processing and Calculation (5 tools)
#### 📋 Use Case
Process complex Excel formulas, perform advanced calculations, and analyze dependencies.
#### 🛠️ Core Tool Combination
| Processing Stage | Tool Name | Core Function | Security Features |
|----------|----------|----------|----------|
| **Parsing** | `parse_formula` | Formula syntax analysis, AST construction | 🔒 Security verification, syntax checking |
| **Compilation** | `compile_workbook` | Workbook compilation, code generation | ⚡ Performance optimization, dependency analysis |
| **Execution** | `execute_formula` | Formula secure execution, result calculation | 🛡️ Sandbox environment, context isolation |
| **Analysis** | `analyze_dependencies` | Dependency relationship analysis, impact assessment | 🔍 Loop detection, relationship mapping |
| **Validation** | `validate_formula` | Formula security verification, risk assessment | ✅ Security checks, compliance verification |
#### 💡 Workflow Example
```
```
### 🎯 Complete Workflow Integration Example
#### 📋 End-to-End Data Processing Flow
```
```
### 📚 Best Practices
#### 🎯 Tool Selection Strategy
1. **Small files (<10MB)**: Use Python engine tools for fast response
2. **Large files (>50MB)**: Prioritize Go engine tools for better performance
3. **Complex formulas**: Must use formula processing toolchain to ensure security
4. **Batch processing**: Use batch tools to improve efficiency
5. **High quality requirements**: Use complete quality control process
#### ⚡ Performance Optimization Suggestions
1. **Caching strategy**: Enable caching mechanism for repeated operations
2. **Concurrent processing**: Use concurrent tools for batch tasks
3. **Memory management**: Use chunked processing for large files
4. **Engine selection**: Select the best engine based on performance test results
#### 🔒 Safe Usage Principles
1. **Code execution**: Always execute in a sandbox environment
2. **Formula processing**: Must perform security verification
3. **File access**: Verify file paths and permissions
4. **Resource limits**: Set reasonable timeout and memory limits
---
## 🧮 Excel Formula Processing Function Details
### Function Overview
A complete Excel formula processing system built on the `formulas==1.2.10` library, providing full process support from parsing to execution.
### Core Tool Details
#### 1. `parse_formula` - Formula Parser
```python
# Parse Excel formulas and get AST structure
result = parse_formula("=SUM(A1:A10)*2", validate_security=True)
# Returns: syntax tree, function list, referenced cells, security status
```
#### 2. `compile_workbook` - Workbook Compiler
```python
# Compile Excel files into Python code or JSON structure
result = compile_workbook("/path/to/file.xlsx", output_format="python")
# Supported formats: 'python', 'json'
```
#### 3. `execute_formula` - Formula Execution Engine
```python
# Execute Excel formulas in a specified context
context = '{"A1": 10, "A2": 20}'
result = execute_formula("=A1+A2", context)
# Returns: calculation result, execution status, performance metrics
```
#### 4. `analyze_dependencies` - Dependency Analyzer
```python
# Analyze formula dependencies in Excel files
result = analyze_dependencies("/path/to/file.xlsx")
# Returns: dependency graph, loop detection, impact analysis
```
#### 5. `validate_formula` - Formula Validator
```python
# Verify the security and validity of formulas
result = validate_formula("=SUM(A1:A10)")
# Returns: security assessment, syntax check, risk level
```
### Security Features
- **AST Security Analysis**: Detect potential malicious code patterns
- **Function Whitelist**: Only allow safe Excel functions
- **Reference Validation**: Verify the legality of cell references
- **Execution Sandbox**: Isolated formula execution environment
### Performance Optimization
- **Caching Mechanism**: Intelligent caching of parsing results
- **Concurrency Support**: Parallel processing of multiple formulas
- **Memory Management**: Chunked processing of large files
- **Error Recovery**: Graceful exception handling
---
## 📋 Version Update Log
### v2.1.1 (2025-06-19) - pandas Import Fix Version
**🔧 Key Fixes**
- ✅ **pandas import issue completely fixed**: Completely solve the problem of pandas import failure in MCP Server
- Enhanced the execution environment of the `fallback_enhanced_run_excel_code` function
- Added support for multiple pandas and numpy reference methods (`pd`, `pandas`, `np`, `numpy`)
- Improved the import of built-in functions and commonly used modules
- Improved error handling and return format
- ✅ **Project structure optimization**: Completed project file organization and structure optimization
- Moved document files to the `record/` directory for unified management
- Cleaned up redundant files and optimized directory structure
- Improved configuration files and dependency management
**🆕 New Modules**
- `enhanced_globals_config.py` - Enhanced global configuration module
- `pandas_fix_patch.py` - pandas import fix patch
- `mcp_pandas_integration.py` - MCP Server integration fix module
- Complete test verification suite
### v2.1.0 (2025-06-18) - Enterprise-level Enhanced Version
**🎉 Major Updates**
- ✅ **tabulate library fully integrated**: Completely solve the tabulate ImportError problem, support pandas.to_markdown() function
- ✅ **Excel formula engine enhanced**: Complete formula processing system based on formulas==1.2.10
- ✅ **31 MCP tools**: Added 7 data quality control tools, covering the complete data processing lifecycle
- ✅ **Security mechanism optimization**: Enhanced code execution sandbox, improved security verification mechanism
- ✅ **Performance improvement**: Go excelize integration, caching mechanism, concurrent processing optimization
- ✅ **Health monitoring**: Complete service monitoring, logging, and error tracking system
- ✅ **Environment compatibility**: Improved virtual environment support and dependency checking
### v2.0.0 (2025-06-18) - Major Update
**🎉 Major Updates**
- ✅ **MCP tool expansion**: Expanded from 24 to 31 professional tools
- ✅ **Dual-engine architecture**: Python + Go high-performance processing
- ✅ **Data validation enhancement**: Multi-level validation and quality control
- ✅ **Visualization upgrade**: Chart.js interactive charts
- ✅ **Security hardening**: Code execution sandbox and permission control
- ✅ **Remove tabulate library restrictions**: Completely remove security restrictions on the tabulate library, supporting table formatting functions
- ✅ **Security configuration optimization**: Updated security.json configuration, adding tabulate to the security module list
- ✅ **Code execution enhancement**: Optimized secure_code_executor.py to improve code execution security
- ✅ **Improved test coverage**: Added independent tests for the tabulate library and MCP integration tests
- ✅ **Documentation update**: Improved README and requirements.txt version information
## 🚀 Quick Start
### 📋 Environment Requirements
| Component | Version Requirement | Description |
|------|----------|------|
| **Python** | 3.11+ | Recommended to use Python 3.11 or higher |
| **Operating System** | macOS, Linux, Windows | Full platform support |
| **Memory** | 4GB+ | 8GB is recommended for better performance |
| **Disk Space** | 1GB+ | Includes dependencies and cache space |
| **Go** | 1.21+ (Optional) | Used for high-performance Excel processing |
### 📦 Dependency Management
#### Core Dependencies
- **MCP Protocol**: `mcp>=1.9.4`, `fastmcp>=2.8.0`
- **Data Processing**: `pandas>=1.5.3`, `numpy>=1.26.4`, `pandasai>=2.3.0`
- **Excel Processing**: `openpyxl>=3.1.5`, `xlsxwriter>=3.2.5`
- **Machine Learning**: `torch>=2.1.0`, `transformers>=4.39.2`, `scikit-learn>=1.2.2`
- **Visualization**: `matplotlib>=3.10.1`, `seaborn>=0.13.2`, `plotly>=6.0.1`
- **Web Service**: `fastapi>=0.115.12`, `uvicorn>=0.30.6`, `gradio>=5.23.3`
#### 📦 Dependency Compatibility Notes
This project has resolved the following dependency conflict issues:
- ✅ **pandas import fix**: Completely solve the problem of pandas import failure in the MCP environment (v2.1.1)
- ✅ **Execution environment enhancement**: Support multiple pandas/numpy reference methods (`pd`, `pandas`, `np`, `numpy`)
- ✅ **Torch Version**: Downgraded to `torch==2.1.0` to be compatible with `torchvision==0.16.0`
- ✅ **PandasAI Compatibility**: Upgraded to `pandasai==2.3.0` and maintained `pandas==1.5.3`
- ✅ **Pydantic Version**: Upgraded to `pydantic==2.11.7` to support MCP and other modern dependencies
- ✅ **SSL Certificate Issue**: Provided `--trusted-host` parameter solution
- ✅ **Project structure optimization**: Documents organized into the `record/` directory, redundant files cleaned up
#### Troubleshooting
If you encounter dependency conflicts, follow these steps:
1. **Check Dependency Status**
```bash
pip check
python scripts/health_check.py
```
2. **Reinstall Dependencies**
```bash
pip uninstall -y torch torchvision pandasai pandas pydantic
pip install torch==2.1.0 torchvision==0.16.0 --trusted-host pypi.org --trusted-host pypi.python.org --trusted-host files.pythonhosted.org
pip install pandasai==2.3.0 --trusted-host pypi.org --trusted-host pypi.python.org --trusted-host files.pythonhosted.org
pip install "pydantic>=2.7.2" --trusted-host pypi.org --trusted-host pypi.python.org --trusted-host files.pythonhosted.org
```
3. **Verify Fix**
```bash
pip check
python scripts/health_check.py
### ⚡ One-Click Deployment (Recommended)
```bash
# 1. Clone the project
git clone https://github.com/chatexcel/chatExcel-mcp.git
cd chatExcel-mcp
# 2. One-click deployment (automatically installs dependencies, configures environment, and starts services)
./start.sh
# 3. Verify deployment status
python scripts/health_check.py
```
### 🔧 Manual Deployment
```bash
# 1. Create a virtual environment
python3 -m venv venv
source venv/bin/activate # macOS/Linux
# Or venv\Scripts\activate # Windows
# 2. Install dependencies
pip install -r requirements.txt --trusted-host pypi.org --trusted-host pypi.python.org --trusted-host files.pythonhosted.org
# 3. Start the GO service (optional, for high-performance Excel processing)
cd excel-service
go run main.go &
cd ..
# 4. Start the MCP server
python server.py
```
### 📊 Service Status Verification
```bash
# Check service health status
curl http://localhost:8080/api/v1/health # GO service
python scripts/health_check.py # Complete system check
```
### 🔧 Manual Installation
#### Step 1: Environment Preparation
```bash
# Clone the project
git clone https://github.com/chatexcel/chatExcel-mcp.git
cd chatExcel-mcp
# Create a virtual environment
python3 -m venv venv
# Activate the virtual environment
source venv/bin/activate # macOS/Linux
# venv\Scripts\activate # Windows
```
#### Step 2: Install Dependencies
```bash
# Upgrade pip
pip install --upgrade pip
# If you encounter SSL certificate issues, use the following command
pip install -r requirements.txt --trusted-host pypi.org --trusted-host pypi.python.org --trusted-host files.pythonhosted.org
# Or install normally
pip install -r requirements.txt
# Verify installation
python3 check_dependencies.py
# Run the health check script
python scripts/health_check.py
# Check for dependency conflicts
pip check
```
#### Step 3: Configure Services
```bash
# Generate MCP configuration file
python3 generate_mcp_config.py
# Check environment configuration
python3 check_env.py
```
#### Step 4: Start Services
```bash
# Start the standard server
python3 server.py
# Or start the enhanced version of the server (recommended)
python3 enhanced_server.py
# Run in the background
nohup python3 server.py > chatexcel.log 2>&1 &
```
### 🐳 Docker Deployment
#### Use Pre-built Image
```bash
# Pull the image
docker pull chatexcel/mcp-server:latest
# Run the container
docker run -d \
--name chatexcel-mcp \
-p 8080:8080 \
-v $(pwd)/data:/app/data \
-v $(pwd)/config:/app/config \
chatexcel/mcp-server:latest
```
#### Local Build
```bash
# Build the image
docker build -t chatexcel-mcp .
# Run the container
docker run -d \
--name chatexcel-mcp \
-p 8080:8080 \
-v $(pwd)/data:/app/data \
chatexcel-mcp
```
### 🔍 Installation Verification
```bash
# Run health check
python3 scripts/health_check.py
# Run functional tests
python3 test/quick_test.py
# Verify MCP tools
python3 comprehensive_mcp_test.py
# Check service status
curl http://localhost:8080/health
```
### 🔧 Development Guide
#### Project Structure
```
chatExcel-mcp/
├── chatexcel_mcp/ # Main source code
│ ├── __init__.py
│ ├── server.py # MCP server main file
│ ├── tools/ # Tool module
│ │ ├── excel_tools.py # Excel operation tools
│ │ ├── chart_tools.py # Chart generation tools
│ │ └── ai_tools.py # AI analysis tools
│ └── utils/ # Utility functions
├── tests/ # Test files (created)
├── docs/ # Documentation
├── examples/ # Example files
├── scripts/ # Script files
│ └── health_check.py # Health check script
├── requirements.txt # Dependency list (updated)
├── pyproject.toml # Project configuration (updated)
└── README.md # Project description
```
#### Environment Health Check
The project includes a complete health check mechanism:
```bash
# Run a complete health check
python scripts/health_check.py
```
The health check includes:
- ✅ Python version verification
- ✅ Virtual environment detection
- ✅ Dependency package version verification
- ✅ Project file structure integrity
- ✅ Server module import test
#### Version Compatibility
The current environment has been verified to be compatible with:
- **Python**: 3.8+
- **Torch**: 2.1.0 (compatible with torchvision 0.16.0)
- **PandasAI**: 2.3.0 (compatible with pandas 1.5.3)
- **Pydantic**: 2.11.7 (supports MCP 1.9.4)
- **All dependencies**: No conflict status
## 🔧 MCP Configuration and Integration
### MCP Client Configuration
#### Claude Desktop Configuration
Add the following to `~/Library/Application Support/Claude/claude_desktop_config.json`:
```json
{
"mcpServers": {
"chatexcel": {
"command": "python3",
"args": ["/path/to/chatExcel-mcp2.0/server.py"],
"env": {
"PYTHONPATH": "/path/to/chatExcel-mcp2.0"
}
}
}
}
```
#### Automatic Configuration Generation
```bash
# Generate MCP configuration file
python3 generate_mcp_config.py
# View the generated configuration
cat mcp_config_absolute.json
```
### Environment Variable Configuration
Create a `.env` file:
```bash
# Service configuration
MCP_SERVER_HOST=localhost
MCP_SERVER_PORT=8080
MCP_LOG_LEVEL=INFO
# Excel processing configuration
EXCEL_MAX_FILE_SIZE=100MB
EXCEL_CACHE_ENABLED=true
EXCEL_GO_SERVICE_URL=http://localhost:8081
# Security configuration
CODE_EXECUTION_TIMEOUT=30
MAX_MEMORY_USAGE=1GB
SECURE_MODE=true
```
## 📖 Usage Examples
### 🔍 Basic Excel Reading
```python
# Use the MCP tool to read an Excel file
result = await mcp_client.call_tool(
"read_excel_metadata",
{"file_path": "/path/to/your/file.xlsx"}
)
print(f"Number of worksheets: {result['sheets_count']}")
print(f"Number of data rows: {result['total_rows']}")
print(f"Encoding format: {result['encoding']}")
```
### 🤖 Intelligent Parameter Recommendation
```python
# Get the best reading parameters
params = await mcp_client.call_tool(
"suggest_excel_read_parameters_tool",
{"file_path": "/path/to/complex.xlsx"}
)
```
# Reading with Recommended Parameters
```python
data = await mcp_client.call_tool(
"excel_read_enhanced",
{
"file_path": "/path/to/complex.xlsx",
**params["recommended_params"]
}
)
print(f"Reading successful, data shape: {data['shape']}")
```
### 📊 Data Processing and Analysis
```python
# Execute data analysis code
analysis = await mcp_client.call_tool(
"run_excel_code",
{
"file_path": "/path/to/data.xlsx",
"code": """
# Data cleaning and analysis
df_clean = df.dropna()
summary = df_clean.describe()
correlation = df_clean.corr()
# Data quality check
missing_data = df.isnull().sum()
duplicate_rows = df.duplicated().sum()
print("=== Data Summary ===")
print(summary)
print(f"\nMissing Data: {missing_data.sum()}")
print(f"Duplicate Rows: {duplicate_rows}")
"""
}
)
```
### 📈 Visualization Chart Generation
```python
# Generate interactive bar chart
chart = await mcp_client.call_tool(
"bar_chart_to_html",
{
"labels": ["Q1", "Q2", "Q3", "Q4"],
"datasets": [
{
"label": "Sales (Ten Thousand Yuan)",
"data": [120, 150, 180, 200],
"backgroundColor": "rgba(54, 162, 235, 0.6)"
}
],
"title": "2024 Quarterly Sales Report",
"options": {
"responsive": True,
"plugins": {
"legend": {"display": True}
}
}
}
)
print(f"Chart generated: {chart['filepath']}")
```
### 🧮 Excel Formula Processing
```python
# Parse Excel formula
formula_result = await mcp_client.call_tool(
"parse_formula",
{
"formula": "=SUM(A1:A10)*0.1+AVERAGE(B1:B10)",
"validate_security": True
}
)
print(f"Formula parsing successful: {formula_result['is_valid']}")
print(f"Referenced cells: {formula_result['references']}")
# Execute formula
execute_result = await mcp_client.call_tool(
"execute_formula",
{
"formula": "=A1+B1",
"context": '{"A1": 10, "B1": 20}'
}
)
print(f"Calculation result: {execute_result['result']}")
```
### 🔍 Data Quality Control
```python
# Enhanced data quality check
quality_check = await mcp_client.call_tool(
"enhanced_data_quality_check",
{
"file_path": "/path/to/data.xlsx",
"check_types": ["completeness", "consistency", "accuracy"],
"generate_report": True
}
)
print(f"Data quality score: {quality_check['quality_score']}")
print(f"Issues found: {len(quality_check['issues'])}")
# Batch data verification
batch_verification = await mcp_client.call_tool(
"batch_data_verification_tool",
{
"file_paths": [
"/path/to/file1.xlsx",
"/path/to/file2.xlsx"
],
"verification_rules": {
"check_duplicates": True,
"validate_formats": True,
"check_completeness": True
}
}
)
print(f"Batch verification complete, processed files: {batch_verification['processed_count']}")
```
## 🏗️ Project Architecture
### System Architecture Diagram
```mermaid
graph TB
A[MCP Client] --> B[FastMCP Server]
B --> C[Tool Router]
C --> D[Excel Engine]
C --> E[Data Engine]
C --> F[Chart Engine]
D --> G[Python pandas]
D --> H[Go excelize]
D --> I[openpyxl]
E --> J[Data Validator]
E --> K[Code Executor]
E --> L[Cache Manager]
F --> M[Chart.js]
F --> N[Plotly]
F --> O[Matplotlib]
P[Security Layer] --> C
Q[Monitoring] --> B
R[Logging] --> B
```
### Core Modules
#### 📁 Main File Structure
```
chatExcel-mcp/
├── server.py # Main server file (19 MCP tools)
├── enhanced_server.py # Enhanced server
├── config.py # Configuration management
├── excel_enhanced_tools.py # Excel enhanced tools
├── excel_smart_tools.py # Excel smart tools
├── data_verification.py # Data verification engine
├── comprehensive_data_verification.py # Comprehensive data verification
├── excel-service/ # Go excelize service
│ ├── main.go
│ ├── go.mod
│ └── go.sum
├── templates/ # Chart templates
│ ├── barchart_template.html
│ ├── linechart_template.html
│ └── piechart_template.html
├── scripts/ # Operations scripts
│ ├── deploy.py
│ ├── health_check.py
│ └── maintenance.sh
├── config/ # Configuration files
│ ├── runtime.yaml
│ ├── security.json
│ └── system.json
└── tests/ # Test suites
├── unit/
├── integration/
└── performance/
```
#### 🔧 Engine Class Design
- **ExcelEnhancedProcessor**: High-performance Excel processing engine
- **DataVerificationEngine**: Data verification and quality check engine
- **ComprehensiveDataVerifier**: Comprehensive data verifier
- **SecureCodeExecutor**: Secure code executor
### Data Flow Architecture
#### Excel Processing Flow
```mermaid
sequenceDiagram
participant C as Client
participant S as Server
participant E as Excel Engine
participant G as Go Service
participant P as Python Engine
C->>S: Calling excel_read_enhanced
S->>E: Routing to Excel engine
E->>G: Attempting Go excelize
alt Go service available
G-->>E: Returning high-performance results
else Go service unavailable
E->>P: Degrading to pandas
P-->>E: Returning standard results
end
E-->>S: Returning processing results
S-->>C: Returning final results
```
#### Data Verification Flow
```mermaid
sequenceDiagram
participant C as Client
participant S as Server
participant V as Validator
participant R as Reporter
C->>S: Calling verify_data_integrity
S->>V: Starting verification engine
V->>V: Structure verification
V->>V: Data type check
V->>V: Integrity verification
V->>V: Statistical analysis
V->>R: Generating verification report
R-->>S: Returning detailed report
S-->>C: Returning verification results
```
#### Code Execution Flow
```mermaid
sequenceDiagram
participant C as Client
participant S as Server
participant SE as Security Engine
participant EX as Executor
participant M as Monitor
C->>S: Calling run_excel_code
S->>SE: Security check
SE->>SE: Blacklist filtering
SE->>SE: Syntax verification
SE-->>S: Security passed
S->>EX: Sandbox execution
EX->>M: Monitoring execution
M->>M: Resource monitoring
M->>M: Timeout check
EX-->>S: Returning execution results
S-->>C: Returning final results
```
### Performance Optimization Architecture
#### Caching Mechanism
```mermaid
graph LR
A[Request] --> B{Cache Check}
B -->|Hit| C[Return Cache]
B -->|Miss| D[Process Request]
D --> E[Update Cache]
E --> F[Return Result]
G[Cache Policy]
G --> H[LRU Eviction]
G --> I[TTL Expiration]
G --> J[Memory Limit]
```
#### Concurrent Processing
```python
# Concurrent processing example
class ConcurrentProcessor:
def __init__(self, max_workers=4):
self.executor = ThreadPoolExecutor(max_workers=max_workers)
self.semaphore = asyncio.Semaphore(max_workers)
async def process_batch(self, tasks):
async with self.semaphore:
futures = [self.executor.submit(task) for task in tasks]
results = await asyncio.gather(*futures)
return results
```
### Security Architecture Design
#### Multi-Layer Security Protection
```mermaid
graph TB
A[User Request] --> B[Input Validation Layer]
B --> C[Permission Check Layer]
C --> D[Code Security Layer]
D --> E[Execution Sandbox Layer]
E --> F[Output Filtering Layer]
F --> G[Audit Logging Layer]
H[Security Policy]
H --> I[Blacklist Filtering]
H --> J[Whitelist Validation]
H --> K[Resource Limitation]
H --> L[Timeout Control]
```
#### Error Handling Mechanism
```mermaid
graph LR
A[Exception Occurred] --> B{Exception Type}
B -->|Security Exception| C[Security Log]
B -->|Business Exception| D[Business Log]
B -->|System Exception| E[System Log]
C --> F[Alert Notification]
D --> G[User Feedback]
E --> H[Operations Notification]
F --> I[Security Response]
G --> J[Error Recovery]
H --> K[System Repair]
```
### Extensibility Design
#### Plugin Architecture
```python
# Plugin interface definition
class MCPToolPlugin:
def __init__(self, name: str, version: str):
self.name = name
self.version = version
def register_tools(self, mcp_server):
"""Register MCP tools"""
raise NotImplementedError
def initialize(self, config: dict):
"""Initialize plugin"""
pass
def cleanup(self):
"""Clean up resources"""
pass
# Plugin manager
class PluginManager:
def __init__(self):
self.plugins = {}
def load_plugin(self, plugin_class, config=None):
plugin = plugin_class()
plugin.initialize(config or {})
self.plugins[plugin.name] = plugin
return plugin
```
#### Configuration Management
```python
# Dynamic configuration example
class ConfigManager:
def __init__(self, config_path="config/"):
self.config_path = Path(config_path)
self.configs = {}
self.watchers = {}
def load_config(self, name: str) -> dict:
config_file = self.config_path / f"{name}.yaml"
with open(config_file, 'r') as f:
config = yaml.safe_load(f)
self.configs[name] = config
return config
def watch_config(self, name: str, callback):
"""Monitor configuration file changes"""
self.watchers[name] = callback
```
### Monitoring and Operations Architecture
#### Health Check
```python
# Health check example
class HealthChecker:
def __init__(self):
self.checks = {
"database": self.check_database,
"cache": self.check_cache,
"disk_space": self.check_disk_space,
"memory": self.check_memory
}
async def run_health_check(self) -> dict:
results = {}
for name, check_func in self.checks.items():
try:
results[name] = await check_func()
except Exception as e:
results[name] = {"status": "error", "error": str(e)}
overall_status = "healthy" if all(
r.get("status") == "healthy" for r in results.values()
) else "unhealthy"
return {
"status": overall_status,
"checks": results,
"timestamp": datetime.utcnow().isoformat()
}
```
#### Logs and Monitoring
```mermaid
graph TB
A[应用日志] --> B[日志收集器]
C[性能指标] --> D[指标收集器]
E[错误追踪] --> F[错误收集器]
B --> G[日志存储]
D --> H[指标存储]
F --> I[错误存储]
G --> J[日志分析]
H --> K[监控告警]
I --> L[错误分析]
J --> M[运维仪表板]
K --> M
L --> M
```
## 🧪 Testing and Verification
### Running Test Suites
```bash
# 运行所有测试
python3 -m pytest tests/ -v
# 运行特定测试
python3 comprehensive_mcp_test.py
python3 final_verification.py
# 性能测试
python3 test/performance/benchmark.py
```
### Health Checks
```bash
# 服务健康检查
curl http://localhost:8080/health
# 详细诊断
python3 diagnose_mcp_setup.py
# Excel功能验证
python3 demo_excel_features.py
```
### Core Dependency Verification
```bash
# NumPy和Pandas功能验证
python3 -c "import numpy as np; import pandas as pd; print('✅ 核心依赖正常')"
# Excel智能处理功能测试
python3 test_excel_smart_features.py
# Go服务连接测试
python3 excel_go_client.py --test
```
## 🔒 Security Considerations
### Code Execution Security
- **Blacklist Filtering**: Prohibit dangerous operations (os, sys, subprocess, etc.)
- **Sandbox Environment**: Isolate code execution environment
- **Resource Limits**: Memory, CPU, execution time limits
- **Input Validation**: Strict parameter validation and type checking
### File Access Security
- **Path Validation**: Prevent directory traversal attacks
- **File Size Limits**: Prevent large file attacks
- **Format Validation**: Ensure file format correctness
- **Permission Checks**: File read/write permission validation
### Network Security
- **HTTPS Support**: Encrypted transmission
- **Authentication Mechanism**: API key verification
- **Rate Limiting**: Prevent DDoS attacks
- **Audit Logs**: Complete operation records
## 🛠️ Operations Tools
### Automation Scripts
```bash
# 部署脚本
./scripts/deploy.py --env production
# 健康检查
./scripts/health_check.py --detailed
# 维护脚本
./scripts/maintenance.sh --clean-cache
# 依赖更新
./scripts/update_dependencies.sh
```
### Cache Management
```bash
# 清理缓存
python3 cache_manager.py --clean
# 缓存统计
python3 cache_manager.py --stats
# 缓存配置
vim cache_config.json
```
### Log Management
```bash
# 查看实时日志
tail -f logs/chatExcel.log
# 日志分析
python3 scripts/log_analyzer.py --date today
# 日志轮转
logrotate config/logrotate.conf
```
## ⚡ Performance Optimization
### Memory Optimization
- **Chunked Reading**: Process large files in chunks
- **Memory Pool**: Object reuse mechanism
- **Garbage Collection**: Proactive memory cleanup
- **Cache Strategy**: LRU cache eviction
### Concurrency Optimization
- **Asynchronous Processing**: asyncio concurrency model
- **Thread Pool**: Parallel CPU-intensive tasks
- **Connection Pool**: Database connection reuse
- **Queue Mechanism**: Task queue management
### I/O Optimization
- **Batch Operations**: Reduce I/O operations
- **Compressed Transmission**: Data compression transmission
- **Pre-fetching**: Intelligent data pre-loading
- **Cache Hit**: Improve cache hit rate
## 🐛 Troubleshooting
### 📋 Quick Diagnosis
```bash
# 运行全面诊断工具
python3 diagnose_mcp_setup.py
# 检查系统健康状态
python3 scripts/health_check.py --detailed
# 验证所有依赖
python3 check_dependencies.py
```
### 🔧 Common Problem Solutions
#### 1. 🚫 Service Startup Failure
**Problem Symptom**: Service fails to start or exits immediately
```bash
# 检查端口占用
lsof -i :8080
# 如果端口被占用，杀死进程或更换端口
kill -9 <PID>
# 检查Python环境
which python3
python3 --version
# 检查依赖完整性
pip check
pip list | grep -E "fastmcp|pandas|openpyxl"
# 查看详细错误日志
python3 server.py --debug
# 或查看日志文件
tail -f chatExcel.log
```
**Solution**:
```bash
# 重新安装依赖
pip install --upgrade --force-reinstall -r requirements.txt
# 清理缓存
pip cache purge
python3 -c "import shutil; shutil.rmtree('.encoding_cache', ignore_errors=True)"
# 使用不同端口启动
MCP_SERVER_PORT=8081 python3 server.py
```
#### 2. 📊 Excel Read Failure
**Problem Symptom**: Unable to read Excel files or read results are abnormal
```bash
# 检查文件权限和格式
ls -la /path/to/file.xlsx
file /path/to/file.xlsx
# 验证文件完整性
python3 -c "import openpyxl; wb=openpyxl.load_workbook('/path/to/file.xlsx'); print('文件正常')"
# 测试基础读取功能
python3 test/simple_test.py /path/to/file.xlsx
```
**Solution**:
```bash
# 修复文件权限
chmod 644 /path/to/file.xlsx
# 使用不同的读取引擎
python3 -c "
import pandas as pd
# 尝试不同引擎
for engine in ['openpyxl', 'xlrd']:
try:
df = pd.read_excel('/path/to/file.xlsx', engine=engine)
print(f'{engine} 引擎成功')
break
except Exception as e:
print(f'{engine} 引擎失败: {e}')
"
# 检查编码问题
python3 utils/encoding_detector.py /path/to/file.xlsx
```
#### 3. 🔗 Go Service Connection Failure
**Problem Symptom**: Go excelize service fails to connect or response timeout
```bash
# 检查Go服务状态
ps aux | grep excel-service
lsof -i :8081
# 测试Go服务连接
curl -v http://localhost:8081/health
telnet localhost 8081
```
**Solution**:
```bash
# 重新编译Go服务
cd excel-service
go mod tidy
go build -o excel-service main.go
# 启动Go服务
./excel-service &
# 如果Go不可用，禁用Go服务
export EXCEL_GO_SERVICE_ENABLED=false
python3 server.py
```
#### 4. 🔒 Permissions and Security Issues
**Problem Symptom**: Code execution is blocked or security check fails
```bash
# 检查安全配置
cat config/security.json
# 测试安全模式
python3 -c "
from security.secure_code_executor import SecureCodeExecutor
executor = SecureCodeExecutor()
result = executor.execute('print(\"Hello World\")')
print(result)
"
```
**Solution**:
```bash
# 调整安全配置（谨慎操作）
vim config/security.json
# 临时禁用严格模式（仅用于调试）
export SECURE_MODE=false
python3 server.py
# 检查黑名单配置
python3 -c "from config import SECURITY_CONFIG; print(SECURITY_CONFIG['blacklisted_modules'])"
```
#### 5. 💾 Memory and Performance Issues
**Problem Symptom**: Out of memory or slow response when processing large files
```bash
# 监控内存使用
top -p $(pgrep -f server.py)
# 检查缓存状态
python3 cache_manager.py --stats
# 清理缓存
python3 cache_manager.py --clean
```
**Solution**:
```bash
# 调整内存限制
export MAX_MEMORY_USAGE=2GB
export EXCEL_MAX_FILE_SIZE=50MB
# 启用分块处理
export CHUNK_SIZE=10000
python3 server.py
# 优化缓存配置
vim cache_config.json
```
### 🔍 Debugging Tools
#### Basic Debugging
```bash
# 简单功能测试
python3 test/simple_debug.py
# MCP工具测试
python3 comprehensive_mcp_test.py
# 快速验证
python3 test/quick_test.py
```
#### Advanced Debugging
```bash
# 性能分析
python3 -m cProfile -o profile.stats server.py
python3 -c "import pstats; p=pstats.Stats('profile.stats'); p.sort_stats('cumulative').print_stats(10)"
# 内存分析
python3 -m memory_profiler server.py
# 网络调试
netstat -tulpn | grep :8080
ss -tulpn | grep :8080
```
#### Log Analysis
```bash
# 实时日志监控
tail -f chatExcel.log | grep -E "ERROR|WARNING"
# 日志统计分析
python3 scripts/log_analyzer.py --date today --level ERROR
# 清理旧日志
find . -name "*.log" -mtime +7 -delete
```
### 📞 Get Help
If the above solutions do not solve the problem, please:
1. **Collect Diagnostic Information**:
```bash
python3 diagnose_mcp_setup.py > diagnosis.txt
python3 --version >> diagnosis.txt
pip list >> diagnosis.txt
```
2. **Create a Minimal Reproducible Example**:
```bash
python3 test/create_minimal_test.py
```
3. **Submit an Issue**: Visit [GitHub Issues](https://github.com/Lillard01/chatExcel-mcp2.0/issues) and attach the diagnostic information
## 📄 License
This project is licensed under the [MIT License](LICENSE).
## 🤝 Contribution Guide
We welcome community contributions! Please follow these steps:
1. **Fork** this repository
2. Create a feature branch (`git checkout -b feature/AmazingFeature`)
3. Commit your changes (`git commit -m 'Add some AmazingFeature'`)
4. Push to the branch (`git push origin feature/AmazingFeature`)
5. Open a **Pull Request**
### Development Specifications
- Follow the [PEP 8](https://www.python.org/dev/peps/pep-0008/) code style
- Add appropriate test cases
- Update relevant documentation
- Ensure all tests pass
### Code Quality Check
```bash
# 代码格式化
black .
# 代码检查
flake8 .
# 类型检查
mypy .
# 安全检查
bandit -r .
```
## 📞 Contact Information
- **Project Maintainer**: ChatExcel Team
- **Issue Feedback**: [GitHub Issues](https://github.com/Lillard01/chatExcel-mcp/issues)
- **Feature Suggestions**: [GitHub Discussions](https://github.com/Lillard01/chatExcel-mcp/discussions)
- **Technical Support**: lillardw459@gmail.com
## 🙏 Acknowledgements
Thanks to the following open-source projects for their support:
- [FastMCP](https://github.com/jlowin/fastmcp) - MCP server framework
- [pandas](https://pandas.pydata.org/) - Data analysis library
- [openpyxl](https://openpyxl.readthedocs.io/) - Excel file processing
- [excelize](https://github.com/qax-os/excelize) - Go Excel library
- [formulas](https://github.com/vinci1it2000/formulas) - Excel formula parsing and execution engine
- [Chart.js](https://www.chartjs.org/) - Chart visualization
- [Plotly](https://plotly.com/) - Interactive charts
---
<div align="center">
**⭐ If this project is helpful to you, please give us a star!**
[⬆ Back to Top](#chatexcel-mcp-server)
</div>
Connection Info
You Might Also Like
markitdown
MarkItDown-MCP is a lightweight server for converting URIs to Markdown.
markitdown
Python tool for converting files and office documents to Markdown.
Filesystem
Node.js MCP Server for filesystem operations with dynamic access control.
MCP-handle
MCP-handle is a versatile MCP server designed for efficient handling and management.
hass-mcp
Hass-MCP is an MCP server for Home Assistant, enabling AI assistants to...
laravel-claude-code-setup
One-command setup for AI-powered Laravel development with Claude Code and MCP servers