UBOS Asset Marketplace: Empowering AI Agents with MCP Servers

In the rapidly evolving landscape of Artificial Intelligence, the need for seamless integration between large language models (LLMs) and real-world data is paramount. The UBOS Asset Marketplace is designed to address this need, offering robust MCP (Model Context Protocol) Servers that act as a bridge between AI models and external data sources. This overview delves into the capabilities, use cases, and technical features of MCP Servers available on the UBOS platform, with a specific focus on the MCP Development Framework.

What is an MCP Server?

An MCP (Model Context Protocol) server acts as a bridge, allowing AI models to access and interact with external data sources and tools. MCP is an open protocol that standardizes how applications provide context to LLMs. This standardization is crucial for creating versatile and powerful AI agents that can leverage a wide array of information.

Use Cases for MCP Servers

MCP Servers unlock a multitude of use cases across various industries. Here are some notable examples:

1. Enhanced Document Processing:

   • Scenario: A legal firm needs to quickly analyze thousands of documents to prepare for a case.
   • MCP Server Solution: An MCP Server integrated with document processing tools (PDF, Word, Excel) can automatically extract key information, identify relevant clauses, and summarize findings, significantly reducing manual effort and accelerating the preparation process.

2. Web Content Analysis:

   • Scenario: A marketing agency needs to monitor online mentions of their client’s brand and analyze customer sentiment.
   • MCP Server Solution: An MCP Server connected to web scraping tools can collect data from websites, social media platforms, and forums, and then use LLMs to analyze the content, identify trends, and gauge public perception.

3. Data-Driven Decision Making:

   • Scenario: A financial analyst needs to assess the impact of various economic indicators on a company’s stock price.
   • MCP Server Solution: An MCP Server linked to financial databases can retrieve real-time data, perform complex calculations, and generate insights that inform investment decisions.

4. Custom AI Tool Development:

   • Scenario: A software development team wants to extend the functionality of their IDE (Integrated Development Environment) with AI-powered features.
   • MCP Server Solution: By integrating an MCP Server with the IDE, developers can create custom tools that automate code generation, identify bugs, and provide intelligent suggestions, thereby improving productivity and code quality.

5. Automated Report Generation:

   • Scenario: A research organization needs to compile regular reports based on data collected from various sources.
   • MCP Server Solution: An MCP Server can automate the process of gathering data, analyzing it with LLMs, and generating comprehensive reports in a variety of formats, saving time and resources.

Key Features of MCP Servers

The MCP Servers available on the UBOS Asset Marketplace are equipped with a range of features designed to facilitate seamless integration with LLMs and external data sources. These include:

• Comprehensive File Processing: Support for a wide range of file formats (PDF, Word, Excel) with automatic file type detection and appropriate processing methods.
• Web Content Retrieval: Ability to fetch content from any webpage, with robust error handling and encoding management.
• Modular Design: A modular architecture that allows for easy extension and maintenance.
• Efficient Data Handling: Optimized memory usage and temporary file management for handling large files.
• Robust Error Handling: Comprehensive exception capture and detailed error reporting.
• Customizable Tools: A framework for developing custom tools that interact with LLMs and external data sources.

The MCP Development Framework

The MCP Development Framework is a powerful toolset for creating custom tools that interact with LLMs. It provides a structured approach to developing, deploying, and managing MCP Servers. Key components of the framework include:

1. File Processing Tools

• PDF Tool: Extracts text and images from PDF documents, with options for quick preview and full analysis.
• Word Tool: Parses Word documents to extract text, tables, and images.
• Excel Tool: Analyzes Excel files to provide detailed information about worksheets, rows, columns, and data types.

2. Web Content Retrieval Tool

• URL Tool: Fetches the content of any webpage, handling HTTP errors and encoding issues.

3. Core Features

• Smart File Type Recognition: Automatically selects the appropriate processing tool based on file extension.
• Efficient Document Processing: Supports quick preview and full analysis modes for PDF files, accurate text and table extraction for Word files, and efficient handling of large Excel datasets.
• Memory Optimization: Uses temporary files and chunk processing to manage large documents and minimize memory usage.
• Error Handling: Provides detailed error messages and fallback processing methods to ensure service stability.

4. Technical Features

• Multi-Layered Processing Strategy for PDF:

  • First attempts to extract content using PyMuPDF (fast and accurate).
  • If that fails, falls back to PymuPDF4llm (optimized for large language models).
  • Finally, uses PyPDF2 as a backup.

• Performance Optimization:

  • Limits the maximum number of pages processed (30 for full mode, 50 for quick mode).
  • Optimizes image processing (DPI adjustment, size limits).
  • Uses multi-threading for faster processing.

• Word Document Structure Parsing:

  • Extracts document properties (title, author, creation time, etc.).
  • Extracts paragraph content, preserving original formatting.
  • Converts tables to Markdown format.

• Image Information:

  • Provides the number of images in the document.
  • Identifies image citation relationships.

Project Structure

The framework follows a modular design, making it easy to extend and maintain. The project structure is as follows:

mcp_tool/ ├── tools/ │ ├── init.py # Defines the base class and register for tools │ ├── loader.py # Tool loader, automatically loads all tools │ ├── file_tool.py # Comprehensive file processing tool │ ├── pdf_tool.py # PDF parsing tool │ ├── word_tool.py # Word document parsing tool │ ├── excel_tool.py # Excel file processing tool │ └── url_tool.py # URL tool implementation ├── init.py ├── main.py └── server.py # MCP server implementation

Developing Custom Tools

The MCP Development Framework makes it easy to create custom tools. Here’s a step-by-step guide:

1. Create a new Python file in the tools directory (e.g., your_tool.py).
2. Import the necessary dependencies and base class.
3. Create a tool class that inherits from BaseTool.
4. Register the tool using the @ToolRegistry.register decorator.
5. Implement the execute method.

Example Tool Template

python import mcp.types as types from . import BaseTool, ToolRegistry

@ToolRegistry.register class YourTool(BaseTool): “”“Your tool description”“” name = “your_tool_name” # Unique identifier for the tool description = “Your tool description” # Description that will be displayed to users input_schema = { “type”: “object”, “required”: [“param1”], # Required parameters “properties”: { “param1”: { “type”: “string”, “description”: “Description of parameter 1”, }, “param2”: { “type”: “integer”, “description”: “Description of parameter 2 (optional)”, } }, }

async def execute(self, arguments: dict) -> list[types.TextContent | types.ImageContent | types.EmbeddedResource]:
    """Executes the tool logic"""
    # Parameter validation
    if "param1" not in arguments:
        return [types.TextContent(
            type="text",
            text="Error: Missing required argument 'param1'"
        )]
      
    # Get parameters
    param1 = arguments["param1"]
    param2 = arguments.get("param2", 0)  # Get optional parameters, providing default values
  
    # Execute tool logic
    result = f"Processing parameters: {param1}, {param2}"
  
    # Return results
    return [types.TextContent(
        type="text",
        text=result
    )]

Deployment

Docker Deployment (Recommended)

1. Initial Setup:

bash git clone https://github.com/your-username/mcp-framework.git cd mcp-framework cp .env.example .env

2. Using Docker Compose:

bash docker compose up --build -d docker compose logs -f docker compose ps docker compose pause docker compose unpause docker compose down

3. Accessing the Service:

   • SSE Endpoint: http://localhost:8000/sse

4. Cursor IDE Configuration:

   • Settings → Features → Add MCP Server
   • Type: sse
   • URL: http://localhost:8000/sse

Traditional Python Deployment

1. Install System Dependencies:

bash

Ubuntu/Debian

sudo apt-get update sudo apt-get install -y poppler-utils tesseract-ocr tesseract-ocr-chi-sim

macOS

brew install poppler tesseract tesseract-lang

Windows

1. Download and install Tesseract: https://github.com/UB-Mannheim/tesseract/wiki

2. Add Tesseract to the system PATH

2. Install Python Dependencies:

bash python -m venv venv source venv/bin/activate # Linux/Mac

Or

.venvScriptsactivate # Windows pip install -r requirements.txt

3. Start the Service:

bash python -m mcp_tool

Configuration

Environment Variables

Configure the following variables in the .env file:

• MCP_SERVER_PORT: Server port (default: 8000)
• MCP_SERVER_HOST: Bind address (default: 0.0.0.0)
• DEBUG: Debug mode (default: false)
• MCP_USER_AGENT: Custom User-Agent

UBOS Platform: Your Full-Stack AI Agent Development Solution

The UBOS platform complements the MCP Server by providing a comprehensive environment for developing and deploying AI agents. UBOS enables you to:

• Orchestrate AI Agents: Manage and coordinate multiple AI agents to achieve complex tasks.
• Connect with Enterprise Data: Integrate AI agents with your existing data sources for real-time insights.
• Build Custom AI Agents: Create tailored AI agents with your LLM model.
• Multi-Agent Systems: Develop sophisticated multi-agent systems for collaborative problem-solving.

By combining MCP Servers from the UBOS Asset Marketplace with the UBOS platform, you can unlock the full potential of AI agents and drive innovation across your organization.

In conclusion, MCP Servers on the UBOS Asset Marketplace provide a crucial bridge between AI models and external data, enabling a wide range of use cases and facilitating the development of powerful AI agents. With comprehensive file processing capabilities, robust error handling, and a modular design, these servers are an essential tool for anyone looking to leverage the power of AI.