Content
# ChatExcel MCP Server - Enterprise Enhanced v2.1.1
> **Latest Update (2025-06-19)**: pandas import issue completely fixed, project structure optimized, enterprise 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)
[](#-operation-and-maintenance-tools)
## 🚀 Core Features
### 📊 31 Professional MCP Tools
- **Data Reading and Metadata Analysis** (2 tools): Intelligent encoding detection, structure 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 inspection, intelligent cleaning
- **Excel Formula Processing** (5 tools): Formula parsing, compilation, execution, verification
### 🏗️ 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 context calculation
- **Dependency Analysis**: Dependency graph generation and cycle detection, avoiding calculation deadlocks
- **Formula Verification**: Syntax checking and risk assessment, ensuring formula security
### 🔍 Data Quality Control (Enhanced)
- **Multi-Level Quality Inspection**: 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 whitelist, preventing malicious code execution
- **Execution Sandbox**: Isolated execution environment, protecting system security
- **Access Control**: Fine-grained access control and operation audit
- **Dependency Scanning**: Intelligent dependency analysis and security vulnerability detection
### ⚡ Performance Optimization
- **Intelligent Caching**: Multi-level caching strategy, reducing repeated calculations
- **Concurrent Processing**: Asynchronous task execution, improving processing speed
- **Memory Management**: Large file block 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 lifecycle of Excel data processing, analysis, verification, 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 verification
- **Intelligent Parameter Recommendation** - Automatic detection of Excel file structure and recommendation of optimal reading parameters
- **Enterprise-Grade Security** - Multi-layer security mechanism, 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)
## 🛠️ MCP Tool List
This project provides **31 professional MCP tools**, covering the entire lifecycle of Excel data processing, analysis, verification, formula calculation, and data quality control.
### 📊 Data Reading and Metadata Tools (4)
| Tool Name | Function Description | Main Features |
|---------|----------|----------|
| `read_metadata` | CSV file metadata reading and intelligent analysis | Encoding detection, delimiter recognition, 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 acquisition | Detailed file analysis, worksheet statistics |
### 🔧 Data Processing and Execution Tools (6)
| Tool Name | Function Description | Main 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 reporting |
### 📈 Data Visualization Tools (3)
| Tool Name | Function Description | Main 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)
| Tool Name | Function Description | Main Features |
|---------|----------|----------|
| `verify_data_integrity` | Data integrity verification and comparison | 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 and approval |
### 🤖 Intelligent Auxiliary Tools (3)
| Tool Name | Function Description | Main Features |
|---------|----------|----------|
| `suggest_excel_read_parameters_tool` | Excel reading parameter intelligent recommendation | Structure analysis, parameter optimization |
| `detect_excel_file_structure_tool` | Excel file structure detection | Multi-level header, data area recognition |
| `create_excel_read_template_tool` | Excel reading code template generation | Intelligent template, parameter configuration |
### 🧮 Excel Formula Processing Tools (5)
| Tool Name | Function Description | Main 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, cycle detection, impact analysis |
| `validate_formula` | Excel formula validator | Security checking, syntax verification, risk assessment |
### 🔍 Data Quality Control Tools (7) - **New**
| Tool Name | Function Description | Main Features |
|---------|----------|----------|
| `enhanced_data_quality_check` | Enhanced data quality inspection | Multi-level quality inspection, 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 screening |
| `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 - 31 MCP Tool Full-Process Guide
This chapter categorizes and associates the 31 MCP tools according to actual user scenarios and data processing workflows, providing a complete workflow usage guide.
### 🎯 Data Processing Workflow Overview
```mermaid
flowchart TD
A[📁 Data Source] --> B[🔍 Data Exploration Stage]
B --> C[📊 Data Reading Stage]
C --> D[🔧 Data Processing Stage]
D --> E[✅ Data Verification Stage]
E --> F[📈 Data Visualization Stage]
F --> G[🧮 Formula Calculation Stage]
G --> H[🔍 Quality Control Stage]
H --> I[📤 Data Output Stage]
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 Inspection]
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]
```
### 🚀 Stage 1: Data Exploration and Preparation (7 tools)
#### 📋 Usage Scenario
When you receive a new Excel file, you first need to understand the file structure, data characteristics, and optimal reading methods.
#### 🛠️ Core Tool Combination
| Step | Tool Name | Usage Purpose | Output Result |
|------|----------|----------|----------|
| 1️⃣ | `excel_info_enhanced` | Acquire file basic 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` | Parameter intelligent recommendation | Optimal reading parameter configuration |
| 5️⃣ | `create_excel_read_template_tool` | Generate reading template | Executable reading code template |
#### 💡 Workflow Example
```
```
### 📊 Stage 2: Data Reading and Loading (4 tools)
#### 📋 Usage Scenario
Based on the analysis results of the exploration stage, perform efficient and accurate data reading operations.
#### 🛠️ Core Tool Combination
| Tool Name | Applicable Scenario | Core Advantage | 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 | Automated encoding detection, delimiter recognition | Lightweight, fast response |
| `read_excel_metadata` | Excel metadata dedicated | 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
```
```
### 🔧 Stage 3: Data Processing and Conversion (6 tools)
#### 📋 Usage Scenario
Perform cleaning, conversion, calculation, and processing operations on the read data.
#### 🛠️ Core Tool Combination
| Processing Type | Tool Name | Function 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 | 📊 Multi-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
```
```
### ✅ Stage 4: Data Verification and Quality Control (10 tools)
#### 📋 Usage Scenario
Ensure data quality, integrity, and accuracy, which is a critical link in the data processing workflow.
#### 🛠️ Core Tool Combination
##### 🔍 Basic Verification Tools (3)
| Tool Name | Verification Focus | Output Report |
|----------|----------|----------|
| `verify_data_integrity` | Data integrity and consistency verification | Detailed verification report, problem location |
| `validate_data_quality` | Data quality assessment and improvement suggestions | Quality scoring, optimization suggestions |
| `comprehensive_data_verification_tool` | Comprehensive verification and assessment | Complete verification report, quality certification |
##### 🧹 Advanced Quality Control Tools (7)
| Tool Name | Professional Field | Core Function |
|----------|----------|----------|
| `enhanced_data_quality_check` | Multi-level quality inspection | Deep quality analysis, comprehensive assessment |
| `extract_cell_content_advanced` | Content extraction and analysis | Multi-type extraction, formatted processing |
| `convert_character_formats` | Character format standardization | Batch conversion, rule configuration |
| `extract_multi_condition_data` | Complex condition screening | Multi-dimensional screening, flexible configuration |
| `merge_multiple_tables` | Multi-table data integration | Intelligent merging, relationship processing |
| `clean_excel_data` | Data cleaning and optimization | Comprehensive cleaning, quality improvement |
| `batch_process_excel_files` | Batch file processing | Parallel processing, unified standards |
#### 💡 Workflow Example
```
```
### 📈 Stage 5: Data Visualization and Reporting (3 tools)
#### 📋 Usage Scenario
Convert processed data into intuitive charts and interactive visualization reports.
#### 🛠️ Core Tool Combination
| Chart Type | Tool Name | Applicable Scenario | Technical Characteristics |
|----------|----------|----------|----------|
| **Bar Chart** | `bar_chart_to_html` | Classification data comparison, trend analysis | Chart.js, responsive design |
| **Pie Chart** | `pie_chart_to_html` | Proportion analysis, composition display | Animation effects, data labels |
| **Line Chart** | `line_chart_to_html` | Time series, trend changes | Multi-dimensional data, interactive zooming |
#### 💡 Workflow Example
```
```
### 🧮 Stage 6: Excel Formula Processing and Calculation (5 tools)
#### 📋 Usage Scenario
Handle complex Excel formulas, perform advanced calculations, and analyze dependency relationships.
#### 🛠️ Core Tool Combination
| Processing Stage | Tool Name | Core Function | Security Characteristics |
|----------|----------|----------|----------|
| **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 | 🔍 Cycle detection, relationship graph |
| **Verification** | `validate_formula` | Formula security verification, risk assessment | ✅ Security checking, 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 quick response
2. **Large Files (>50MB)**: Prioritize Go engine tools for better performance
3. **Complex Formulas**: Must use formula processing tool chain to ensure security
4. **Batch Processing**: Use batch tools to improve efficiency
5. **High Quality Requirements**: Use complete quality control processes
#### ⚡ Performance Optimization Suggestions
1. **Cache Strategy**: Enable cache 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**: Choose the best engine based on performance test results
#### 🔒 Secure Use 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 Limitation**: Set reasonable timeout and memory limits
---
## 🧮 Excel Formula Processing Function Details
### Function Overview
Built on the `formulas==1.2.10` library, providing a complete Excel formula processing system from parsing to execution.
### Core Tool Details
#### 1. `parse_formula` - Formula Parser
```python
# Parse Excel formula 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 file 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 formula in 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 file
result = analyze_dependencies("/path/to/file.xlsx")
# Returns: dependency graph, cycle detection, impact analysis
```
#### 5. `validate_formula` - Formula Validator
```python
# Validate formula security and effectiveness
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 secure Excel functions
- **Reference Verification**: Verify cell reference legitimacy
- **Execution Sandbox**: Isolated formula execution environment
### Performance Optimization
- **Cache Mechanism**: Intelligent caching of parsing results
- **Concurrent 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
**🔧 Key Fixes**
- ✅ **pandas Import Issue Completely Fixed**: Thoroughly resolve pandas import failure in MCP server
- Enhanced execution environment for `fallback_enhanced_run_excel_code` function
- Added multiple pandas and numpy reference methods support (`pd`, `pandas`, `np`, `numpy`)
- Improved import of built-in functions and common modules
- Enhanced error handling and return format
- ✅ **Project Structure Optimization**: Completed project file organization and structure optimization
- Moved documentation files to `record/` directory for unified management
- Cleaned redundant files, 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 testing and verification suite
### v2.1.0 (2025-06-18) - Enterprise-Level Enhancement
**🎉 Major Updates**
- ✅ **tabulate Library Complete Integration**: Thoroughly resolve tabulate ImportError issue, support pandas.to_markdown() functionality
- ✅ **Excel Formula Engine Enhancement**: Complete formula processing system based on formulas==1.2.10
- ✅ **31 MCP Tools**: Added 7 data quality control tools, covering complete data processing lifecycle
- ✅ **Security Mechanism Optimization**: Enhanced code execution sandbox, improved security verification mechanism
- ✅ **Performance Improvement**: Go excelize integration, cache 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**: Extended 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
- ✅ **Removal of tabulate Library Limitation**: Completely removed security restrictions on tabulate library, supporting table formatting functionality
- ✅ **Security Configuration Optimization**: Updated security.json configuration, added tabulate to secure module list
- ✅ **Code Execution Enhancement**: Optimized secure_code_executor.py, improved code execution security
- ✅ **Testing Coverage Improvement**: Added tabulate library independent testing and MCP integration testing
- ✅ **Documentation Update**: Improved README and requirements.txt version information
## 🚀 Quick Start
### 📋 Environment Requirements
| Component | Version Requirements | Description |
|------|--------------------|------|
| **Python** | 3.11+ | Recommended Python 3.11 or higher |
| **Operating System** | macOS, Linux, Windows | Full-platform support |
| **Memory** | 4GB+ | 8GB recommended for better performance |
| **Disk Space** | 1GB+ | Includes dependency and cache space |
| **Go** | 1.21+ (optional) | 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 Description
This project has resolved the following dependency conflicts:
- ✅ **pandas Import Fix**: Completely resolved pandas import failure in MCP environment (v2.1.1)
- ✅ **Execution Environment Enhancement**: Supports 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**: Organized documentation into `record/` directory, cleaned redundant files
#### Troubleshooting
If encountering 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 project
git clone https://github.com/chatexcel/chatExcel-mcp.git
cd chatExcel-mcp
# 2. One-click deployment (automatically install dependencies, configure environment, and start service)
./start.sh
# 3. Verify deployment status
python scripts/health_check.py
```
### 🔧 Manual Deployment
```bash
# 1. Create 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 GO service (optional, for high-performance Excel processing)
cd excel-service
go run main.go &
cd ..
# 4. Start 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 project
git clone https://github.com/chatexcel/chatExcel-mcp.git
cd chatExcel-mcp
# Create virtual environment
python3 -m venv venv
# Activate virtual environment
source venv/bin/activate # macOS/Linux
# venv\Scripts\activate # Windows
```
#### Step 2: Install Dependencies
```bash
# Upgrade pip
pip install --upgrade pip
# If encountering 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 health check script
python scripts/health_check.py
# Check dependency conflicts
pip check
```
#### Step 3: Configure Service
```bash
# Generate MCP configuration file
python3 generate_mcp_config.py
# Check environment configuration
python3 check_env.py
```
#### Step 4: Start Service
```bash
# Start standard server
python3 server.py
# Or start enhanced server (recommended)
python3 enhanced_server.py
# Run in background
nohup python3 server.py > chatexcel.log 2>&1 &
```
### 🐳 Docker Deployment
#### Use Pre-Built Image
```bash
# Pull image
docker pull chatexcel/mcp-server:latest
# Run container
docker run -d \
--name chatexcel-mcp \
-p 8080:8080 \
-v $(pwd)/data:/app/data \
-v $(pwd)/config:/app/config \
chatexcel/mcp-server:latest
```
#### Build Locally
```bash
# Build image
docker build -t chatexcel-mcp .
# Run 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 test
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 modules
│ │ ├── 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 complete health check
python scripts/health_check.py
```
Health check includes:
- ✅ Python version verification
- ✅ Virtual environment detection
- ✅ Dependency package version verification
- ✅ Project file structure integrity
- ✅ Server module import test
#### Version Compatibility
Current environment verified compatibility:
- **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 state
## 🔧 MCP Configuration and Integration
### MCP Client Configuration
#### Claude Desktop Configuration
Add 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 generated configuration
cat mcp_config_absolute.json
```
### Environment Variable Configuration
Create `.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 MCP tool to read Excel file
result = await mcp_client.call_tool(
"read_excel_metadata",
{"file_path": "/path/to/your/file.xlsx"}
)
print(f"Sheet count: {result['sheets_count']}")
print(f"Data rows: {result['total_rows']}")
print(f"Encoding format: {result['encoding']}")
```
### 🤖 Intelligent Parameter Recommendation
```python
# Get optimal read parameters
params = await mcp_client.call_tool(
"suggest_excel_read_parameters_tool",
{"file_path": "/path/to/complex.xlsx"}
)
# Use params for reading Excel file
```
# Tool List
### 📊 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}")
"""
}
)
```
### 📈 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 completed, files processed: {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 suite
├── 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: Call excel_read_enhanced
S->>E: Route to Excel engine
E->>G: Try Go excelize
alt Go service available
G-->>E: Return high-performance result
else Go service unavailable
E->>P: Fallback to pandas
P-->>E: Return standard result
end
E-->>S: Return processing result
S-->>C: Return final result
```
#### Data Verification Flow
```mermaid
sequenceDiagram
participant C as Client
participant S as Server
participant V as Validator
participant R as Reporter
C->>S: Call verify_data_integrity
S->>V: Start verification engine
V->>V: Structure verification
V->>V: Data type check
V->>V: Completeness verification
V->>V: Statistical analysis
V->>R: Generate verification report
R-->>S: Return detailed report
S-->>C: Return verification result
```
#### 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: Call 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: Monitor execution
M->>M: Resource monitoring
M->>M: Timeout check
EX-->>S: Return execution result
S-->>C: Return final result
```
### Performance Optimization Architecture
#### Cache 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 strategy]
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 log layer]
H[Security policy]
H --> I[Blacklist filtering]
H --> J[Whitelist verification]
H --> K[Resource limit]
H --> L[Timeout control]
```
#### Error Handling Mechanism
```mermaid
graph LR
A[Exception occurs] --> 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]
```
### Scalability 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):
"""Cleanup 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()
}
```
#### Log and Monitoring
```mermaid
graph TB
A[Application Logs] --> B[Log Collector]
C[Performance Metrics] --> D[Metrics Collector]
E[Error Tracking] --> F[Error Collector]
B --> G[Log Storage]
D --> H[Metrics Storage]
F --> I[Error Storage]
G --> J[Log Analysis]
H --> K[Monitoring and Alerting]
I --> L[Error Analysis]
J --> M[Operations Dashboard]
K --> M
L --> M
```
## 🧪 Testing and Verification
### Running Test Suites
```bash
# Run all tests
python3 -m pytest tests/ -v
# Run specific tests
python3 comprehensive_mcp_test.py
python3 final_verification.py
# Performance testing
python3 test/performance/benchmark.py
```
### Health Check
```bash
# Service health check
curl http://localhost:8080/health
# Detailed diagnostics
python3 diagnose_mcp_setup.py
# Excel feature verification
python3 demo_excel_features.py
```
### Core Dependency Verification
```bash
# NumPy and Pandas feature verification
python3 -c "import numpy as np; import pandas as pd; print('✅ Core dependencies normal')"
# Excel smart feature testing
python3 test_excel_smart_features.py
# Go service connection test
python3 excel_go_client.py --test
```
## 🔒 Security Considerations
### Code Execution Security
- **Blacklist filtering**: Prohibited dangerous operations (os, sys, subprocess, etc.)
- **Sandbox environment**: Isolated code execution environment
- **Resource limitations**: Memory, CPU, execution time limitations
- **Input validation**: Strict parameter validation and type checking
### File Access Security
- **Path validation**: Prevent directory traversal attacks
- **File size limitations**: Prevent large file attacks
- **Format verification**: Ensure file format correctness
- **Permission checks**: File read and write permission verification
### 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
# Deployment script
./scripts/deploy.py --env production
# Health check
./scripts/health_check.py --detailed
# Maintenance script
./scripts/maintenance.sh --clean-cache
# Dependency update
./scripts/update_dependencies.sh
```
### Cache Management
```bash
# Clean cache
python3 cache_manager.py --clean
# Cache statistics
python3 cache_manager.py --stats
# Cache configuration
vim cache_config.json
```
### Log Management
```bash
# View real-time logs
tail -f logs/chatExcel.log
# Log analysis
python3 scripts/log_analyzer.py --date today
# Log rotation
logrotate config/logrotate.conf
```
## ⚡ Performance Optimization
### Memory Optimization
- **Chunked reading**: Large file chunked processing
- **Memory pool**: Object reuse mechanism
- **Garbage collection**: Active memory cleanup
- **Cache strategy**: LRU cache elimination
### Concurrency Optimization
- **Asynchronous processing**: asyncio concurrency model
- **Thread pool**: CPU-intensive task parallelism
- **Connection pool**: Database connection reuse
- **Queue mechanism**: Task queue management
### I/O Optimization
- **Batch operations**: Reduce I/O times
- **Compressed transmission**: Data compression transmission
- **Pre-reading**: Intelligent data preloading
- **Cache hit**: Improve cache hit rate
## 🐛 Troubleshooting
### 📋 Quick Diagnosis
```bash
# Run comprehensive diagnostic tool
python3 diagnose_mcp_setup.py
# Check system health status
python3 scripts/health_check.py --detailed
# Verify all dependencies
python3 check_dependencies.py
```
### 🔧 Common Problem Solutions
#### 1. 🚫 Service Startup Failure
**Symptoms**: Service cannot start or exit immediately
```bash
# Check port occupancy
lsof -i :8080
# If port is occupied, kill the process or replace the port
kill -9 <PID>
# Check Python environment
which python3
python3 --version
# Check dependency integrity
pip check
pip list | grep -E "fastmcp|pandas|openpyxl"
# View detailed error logs
python3 server.py --debug
# Or view log files
tail -f chatExcel.log
```
**Solution**:
```bash
# Reinstall dependencies
pip install --upgrade --force-reinstall -r requirements.txt
# Clean cache
pip cache purge
python3 -c "import shutil; shutil.rmtree('.encoding_cache', ignore_errors=True)"
# Start with different port
MCP_SERVER_PORT=8081 python3 server.py
```
#### 2. 📊 Excel Read Failure
**Symptoms**: Unable to read Excel file or read result is abnormal
```bash
# Check file permissions and format
ls -la /path/to/file.xlsx
file /path/to/file.xlsx
# Verify file integrity
python3 -c "import openpyxl; wb=openpyxl.load_workbook('/path/to/file.xlsx'); print('File normal')"
# Test basic read functionality
python3 test/simple_test.py /path/to/file.xlsx
```
**Solution**:
```bash
# Repair file permissions
chmod 644 /path/to/file.xlsx
# Use different read engine
python3 -c "
import pandas as pd
# Try different engines
for engine in ['openpyxl', 'xlrd']:
try:
df = pd.read_excel('/path/to/file.xlsx', engine=engine)
print(f'{engine} engine succeeded')
break
except Exception as e:
print(f'{engine} engine failed: {e}')
"
# Check encoding issues
python3 utils/encoding_detector.py /path/to/file.xlsx
```
#### 3. 🔗 Go Service Connection Failure
**Symptoms**: Go excelize service cannot connect or response timeout
```bash
# Check Go service status
ps aux | grep excel-service
lsof -i :8081
# Test Go service connection
curl -v http://localhost:8081/health
telnet localhost 8081
```
**Solution**:
```bash
# Recompile Go service
cd excel-service
go mod tidy
go build -o excel-service main.go
# Start Go service
./excel-service &
# If Go is unavailable, disable Go service
export EXCEL_GO_SERVICE_ENABLED=false
python3 server.py
```
#### 4. 🔒 Permission and Security Issues
**Symptoms**: Code execution is blocked or security check fails
```bash
# Check security configuration
cat config/security.json
# Test security mode
python3 -c "
from security.secure_code_executor import SecureCodeExecutor
executor = SecureCodeExecutor()
result = executor.execute('print(\"Hello World\")')
print(result)
"
```
**Solution**:
```bash
# Adjust security configuration (cautious operation)
vim config/security.json
# Temporarily disable strict mode (only for debugging)
export SECURE_MODE=false
python3 server.py
# Check blacklist configuration
python3 -c "from config import SECURITY_CONFIG; print(SECURITY_CONFIG['blacklisted_modules'])"
```
#### 5. 💾 Memory and Performance Issues
**Symptoms**: Insufficient memory or slow response when processing large files
```bash
# Monitor memory usage
top -p $(pgrep -f server.py)
# Check cache status
python3 cache_manager.py --stats
# Clean cache
python3 cache_manager.py --clean
```
**Solution**:
```bash
# Adjust memory limit
export MAX_MEMORY_USAGE=2GB
export EXCEL_MAX_FILE_SIZE=50MB
# Enable chunked processing
export CHUNK_SIZE=10000
python3 server.py
# Optimize cache configuration
vim cache_config.json
```
### 🔍 Debugging Tools
#### Basic Debugging
```bash
# Simple function test
python3 test/simple_debug.py
# MCP tool test
python3 comprehensive_mcp_test.py
# Quick verification
python3 test/quick_test.py
```
#### Advanced Debugging
```bash
# Performance analysis
python3 -m cProfile -o profile.stats server.py
python3 -c "import pstats; p=pstats.Stats('profile.stats'); p.sort_stats('cumulative').print_stats(10)"
# Memory analysis
python3 -m memory_profiler server.py
# Network debugging
netstat -tulpn | grep :8080
ss -tulpn | grep :8080
```
#### Log Analysis
```bash
# Real-time log monitoring
tail -f chatExcel.log | grep -E "ERROR|WARNING"
# Log statistics and analysis
python3 scripts/log_analyzer.py --date today --level ERROR
# Clean old logs
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 Issue**: Visit [GitHub Issues](https://github.com/Lillard01/chatExcel-mcp2.0/issues) and attach diagnostic information
## 📄 License
This project uses the [MIT License](LICENSE) open-source protocol.
## 🤝 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 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 [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
# Code formatting
black .
# Code check
flake8 .
# Type check
mypy .
# Security check
bandit -r .
```
## 📞 Contact
- **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 for the support of the following open-source projects:
- [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 chart
---
<div align="center">
**⭐ If this project helps you, 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.
TrendRadar
TrendRadar: Your hotspot assistant for real news in just 30 seconds.
mempalace
The highest-scoring AI memory system ever benchmarked. And it's free.
mempalace
The highest-scoring AI memory system ever benchmarked. And it's free.