Llm MCP Tools

🚀 LLM MCP Tools - Intelligent Tool Scheduling System

An intelligent tool scheduling system based on FastMCP 2.0, supporting knowledge graphs, vector search, and real-time progress display

📖 Introduction

LLM MCP Tools is an intelligent tool scheduling system built on Model Context Protocol (MCP) and FastMCP 2.0. Leveraging the Function Calling capabilities of large models, it enables AI to autonomously select and invoke various tools, automating processes from simple calculations to complex knowledge graph analyses.

🎯 Use Cases

• 🏢 Enterprise Knowledge Management: Document upload, vector retrieval, and knowledge graph construction
• 💼 Business Data Analysis: Employee information query, department statistics, and data visualization
• 🤖 Intelligent Assistant Development: Multi-round conversations, tool scheduling, and real-time feedback
• 📚 MCP Protocol Learning: Decoupled architecture, standardized interfaces, and tool registration

✨ Core Features

🔧 Rich Tool Ecosystem

Total: 26+ tool functions

🎨 Unique Advantages

✅ Decoupled Architecture: The MCP Server and Web App are completely separated, supporting independent deployment and scaling.
✅ Automatic Discovery: New tools are automatically registered without modifying client code.
✅ Knowledge Graph: Automatically extracts entity relationships, supporting graph visualization and path queries.
✅ Real-time Progress: Displays real-time progress during document processing, providing a user-friendly experience.
✅ Vector Search: Efficient document retrieval based on ChromaDB.
✅ Multi-round Conversations: Supports context understanding and session management.
✅ Standard Protocol: Follows the MCP standard, facilitating easy expansion and integration.

🏗️ System Architecture

Architecture Diagram

┌─────────────────────────────────────────────────────────────┐
│                     User Browser                                 │
│                 (http://localhost:8000)                      │
└────────────────────────┬────────────────────────────────────┘
                         │ WebSocket (Real-time Communication)
                         ↓
┌─────────────────────────────────────────────────────────────┐
│                    Web App (FastAPI)                         │
│  ┌─────────────┐  ┌──────────────┐  ┌──────────────┐       │
│  │  WebSocket  │  │  MCP Client  │  │  LLM Client  │       │
│  │   Handler   │→ │  (HTTP Call)  │→ │ (Tongyi Qianwen)   │       │
│  └─────────────┘  └──────────────┘  └──────────────┘       │
│                          ↓                                   │
└──────────────────────────┼───────────────────────────────────┘
                           │ HTTP (MCP Protocol)
                           ↓
┌─────────────────────────────────────────────────────────────┐
│               MCP Server (FastMCP 2.0)                       │
│  ┌───────────────────────────────────────────────────────┐  │
│  │             Tool Registration Center (@mcp.tool())                  │  │
│  └───────────────────────────────────────────────────────┘  │
│         ↓              ↓              ↓              ↓       │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌──────────┐   │
│  │ Database Tools │  │ Knowledge Base Tools │  │ Knowledge Graph  │  │ Calculation Tools  │   │
│  └──────────┘  └──────────┘  └──────────┘  └──────────┘   │
└──────┬──────────────┬──────────────┬──────────────┬─────────┘
       │              │              │              │
       ↓              ↓              ↓              ↓
   MySQL      ChromaDB(Vector)  NetworkX(Graph)   External API

Technology Stack

• Backend Framework: FastAPI + FastMCP 2.0
• Large Model: Tongyi Qianwen Qwen (Supports Function Calling)
• Database: MySQL (Structured Data) + ChromaDB (Vector Database)
• Knowledge Graph: NetworkX (Graph Storage) + OpenAI API (Entity Extraction)
• Communication Protocol: WebSocket (Real-time Communication) + HTTP (MCP Protocol)
• Frontend: Native JavaScript + Marked.js (Markdown Rendering)

🚀 Quick Start

Environment Requirements

• Python 3.10+
• MySQL 5.7+ (Optional, for database tools)
• Tongyi Qianwen API Key

1. Clone the Project

git clone https://github.com/houmingya/LLM_MCP_TOOLS.git
cd LLM_MCP_TOOLS

2. Create a Virtual Environment

# Using conda
conda create -n mcp-demo python=3.10 -y
conda activate mcp-demo

# Or using venv
python -m venv venv
source venv/bin/activate  # Linux/Mac
# venv\Scripts\activate  # Windows

3. Install Dependencies

pip install -r requirements.txt

4. Configure Environment Variables

Important: The project uses environment variables to manage sensitive configurations. Do not modify the configurations in the code directly!

Copy the environment variable template:

cp .env.example .env

Edit the .env file and fill in your configurations:

# ========================
# Large Model Configuration (Required)
# ========================
# Tongyi Qianwen API Key (Must be configured)
# Obtain from: https://dashscope.console.aliyun.com/apiKey
LLM_API_KEY=your_qwen_api_key_here

# Model Name (Optional: qwen-plus, qwen-turbo, qwen-max)
LLM_MODEL_NAME=qwen-plus

# ========================
# MySQL Database Configuration (Optional)
# ========================
# Can be left unconfigured if not using database tools
DB_HOST=localhost
DB_PORT=3306
DB_USER=root
DB_PASSWORD=your_mysql_password_here
DB_DATABASE=test_db

# ========================
# Service Port Configuration
# ========================
WEB_PORT=8000
MCP_PORT=8001

For detailed configuration instructions, please refer to: Configuration Guide

5. Validate the Configuration

Run the configuration test:

python test_config.py

If you see "✅ Configuration validation passed", it means the configuration is successful!

6. Start the Service

Method 1: One-click Start (Recommended)

python run.py

This will start the following services simultaneously:

• MCP Server: http://localhost:8001/mcp
• Web App: http://localhost:8000

Method 2: Start Separately (For Development and Debugging)

# Terminal 1 - Start the MCP Server
python run_mcp_server.py

# Terminal 2 - Start the Web App
python run.py --mode webapp

7. Access the Application

Open your browser and visit: http://localhost:8000

💻 Usage Examples

Basic Conversation

👤 Hello, what can you do?
🤖 I can help you with:
   • Querying employee and department information
   • Uploading and searching for documents
   • Constructing and querying knowledge graphs
   • Performing mathematical calculations and statistical analyses
   • Obtaining time information and performing date calculations
   • Initiating HTTP requests and querying the weather

Database Query

👤 How many employees are there in the sales department, and what is the average salary?
🤖 [Call query_employees_by_department(department_id=2)]
   [Call get_department_statistics()]
   
   There are 15 employees in the sales department, and the average salary is 8,500 yuan.

Document Upload and Retrieval

👤 Help me upload this product manual.
🤖 [Call upload_document(file)]
   📤 Uploading the document...
   📝 Split into 23 text chunks
   🧠 Analyzing text chunk 1/5...
   🧠 Analyzing text chunk 2/5...
   ✅ Knowledge graph construction completed!
   
   Document uploaded successfully! 18 entities and 25 relationships have been extracted.

👤 What are the main functions mentioned in this document?
🤖 [Call search_documents(query="main functions")]
   
   According to the document, the main functions include:
   1. Data collection and storage
   2. Real-time monitoring and alarming
   3. Data analysis and visualization
   ...

Knowledge Graph Query

👤 What projects is Inspur Yunzhou related to?
🤖 [Call query_entity(entity_name="Inspur Yunzhou")]
   
   Inspur Yunzhou has the following relationships in the knowledge graph:
   • Developed → Yunzhou Data Governance System
   • Provided → Data Visualization Platform
   • Applied to → Jinchuan Industry Intelligence Platform
   ...

👤 What is the connection between Inspur Yunzhou and Jinchuan Group?
🤖 [Call find_entity_path(source="Inspur Yunzhou", target="Jinchuan Group")]
   
   Relationship path found:
   Inspur Yunzhou → Developed → Decision Support Platform → Applied to → Jinchuan Group

Calculation and Analysis

👤 Calculate (123 + 456) * 2 - 89.
🤖 [Call calculate(expression="(123 + 456) * 2 - 89")]
   
   Calculation result: 1,069

👤 Help me analyze the statistical characteristics of this data set: [23, 45, 67, 89, 12, 34, 56, 78].
🤖 [Call statistics_analysis(data=[23,45,67,89,12,34,56,78])]
   
   Statistical analysis results:
   • Average: 50.5
   • Median: 50.5
   • Standard Deviation: 26.4
   • Minimum: 12, Maximum: 89

📁 Project Structure

LLM_MCP_TOOLS/
├── 📄 README.md                     # Project description document
├── 📄 requirements.txt              # Python dependency list
├── 📄 .env.example                  # Environment variable example
├── 📄 .gitignore                    # Git ignore file
│
├── 🚀 run.py                        # Unified startup entry
├── 🚀 run_decoupled.py             # Startup in decoupled mode (starts two services simultaneously)
├── 🚀 run_mcp_server.py            # Start the MCP Server separately
│
├── ⚙️ config/                       # Configuration module
│   ├── __init__.py
│   └── settings.py                 # Configuration center (database, LLM, ports, etc.)
│
├── 🔧 mcp_server/                   # MCP Server (port 8001)
│   ├── __init__.py
│   ├── server.py                   # 🎯 Tool registration center (@mcp.tool())
│   ├── prompts.py                  # Prompt templates
│   └── tools/                      # Tool implementations
│       ├── __init__.py
│       ├── database_tools.py       # Database tools (6 functions)
│       ├── knowledge_tools.py      # Knowledge base tools (3 functions)
│       ├── knowledge_graph_tools.py # Knowledge graph tools (7 functions)
│       ├── calculation_tools.py    # Calculation tools (3 functions)
│       ├── time_tools.py          # Time tools (4 functions)
│       └── api_tools.py           # API tools (3 functions)
│
├── 🌐 web_app/                      # Web App (port 8000)
│   ├── __init__.py
│   ├── main.py                     # 🎯 FastAPI application + WebSocket + LLM
│   ├── mcp_client.py              # 🎯 MCP Client (HTTP communication)
│   └── static/                    # Frontend static files
│       ├── index.html             # Main page
│       ├── knowledge-graph.html   # Knowledge graph visualization
│       ├── css/
│       │   └── style.css         # Style file
│       └── js/
│           ├── app.js            # Application initialization
│           ├── websocket.js      # WebSocket connection management
│           ├── chat.js           # Chat function
│           ├── message-handler.js # Message processing (including progress display)
│           ├── file-upload.js    # File upload
│           ├── knowledge-graph.js # Knowledge graph visualization
│           └── utils.js          # Utility functions
│
├── 📚 docs/                         # Documentation directory
│   ├── 知识图谱技术深度解析.md
│   ├── 知识图谱应用说明.md
│   ├── 文本块处理进度功能说明.md
│   └── MCP_API_完整对照表.md
│
├── 📤 uploads/                      # Document upload directory (.gitignore)
├── 💾 chroma_db/                    # ChromaDB data directory (.gitignore)
└── 🧠 knowledge_graph_data/         # Knowledge graph data (.gitignore)

🔧 Development Guide

Adding New Tools

Simply add the following code to mcp_server/server.py:

@mcp.tool()
def my_new_tool(param1: str, param2: int = 10) -> Dict[str, Any]:
    """
    Tool description (will be automatically used as the tool's description)
    
    Args:
        param1: Description of parameter 1
        param2: Description of parameter 2, default value is 10
        
    Returns:
        Description of the return value
    """
    # Implement your logic
    result = do_something(param1, param2)
    
    return {
        "success": True,
        "data": result,
        "message": "Execution successful"
    }

Restart the MCP Server, and the Web App will automatically recognize the new tool! ✨
There's no need to modify main.py, the tool list, or the frontend code.

Best Practices for Tool Development

1. Clear Docstrings: Will be passed as tool descriptions to the large model.
2. Type Annotations: Help automatically generate tool parameter schemas.
3. Unified Return Format: It is recommended to include the success, data, and message fields.
4. Error Handling: Catch exceptions and return user-friendly error messages.

Local Development

# Install development dependencies
pip install -r requirements-dev.txt

# Run tests
pytest tests/

# Code formatting
black .
isort .

# Type checking
mypy .

📚 Documentation

• In-depth Analysis of Knowledge Graph Technology
• Knowledge Graph Application Instructions
• Explanation of Text Block Processing Progress Function
• Complete Comparison Table of MCP API

External Resources

• FastMCP Official Documentation
• MCP Protocol Specification
• FastAPI Documentation
• ChromaDB Documentation
• NetworkX Documentation

❓ Frequently Asked Questions

Q: I'm getting an error "Insert of existing embedding ID" from ChromaDB. What should I do?

A: This is caused by uploading the same document multiple times. It has been fixed in the new version. Use upsert instead of add.

Q: What should I do if the port is occupied?

A: Modify the port configurations in config/settings.py:

class WebConfig:
    PORT = 8000  # Change to another port, e.g., 8080

class MCPServerConfig:
    PORT = 8001  # Change to another port, e.g., 8081

Q: Why is the knowledge graph construction so slow?

A: This is normal because it requires calling the large model API for entity extraction. The longer the document, the more time it takes. The new version supports real-time progress display.

Q: How can I use the system without the database tools?

A: The database tools are optional. If you don't need them, simply comment out the registration of the relevant tools in mcp_server/server.py.

Q: Which large models are supported?

A: In theory, all large models compatible with the OpenAI API format are supported. Simply modify the LLMConfig in config/settings.py:

class LLMConfig:
    API_KEY = "your_api_key"
    API_BASE = "https://api.openai.com/v1"  # Or other endpoints
    MODEL_NAME = "gpt-4"  # Or other models

🤝 Contribute

We welcome all forms of contributions! Whether it's new features, bug fixes, documentation improvements, or problem feedback.

Contribution 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 Guidelines

• Follow the PEP 8 code style.
• Add necessary comments and documentation.
• Write unit tests.
• Ensure all tests pass.

📄 License

This project is licensed under the MIT License.

🙏 Acknowledgments

• FastMCP - An excellent MCP implementation framework
• FastAPI - A modern Python Web framework
• ChromaDB - A simple and easy-to-use vector database
• NetworkX - A powerful graph analysis library
• Tongyi Qianwen - Alibaba Cloud's large model service

📧 Contact Information

• GitHub: @houmingya
• Issues: Project Issue Feedback