Development Tools - MCPI Documentation

Development Tools Overview

The MCPI repository provides a complete toolkit for implementing and working with the Model Context Protocol Integration. All components are fully MCP compliant, implementing the Model Context Protocol specification with extensions. Our tools are divided into two main domains: server-side components for hosting MCPI services, and client-side tools for connecting AI agents to those services.

All tools are open source under the MIT License, allowing for maximum flexibility in how you integrate, extend, and deploy them in your projects.

MCP Compliance: Every component follows the official Model Context Protocol specification to ensure compatibility with AI agents that support MCP.

🖥️

Server Components

Rust-based server implementation that provides a WebSocket endpoint for the MCP protocol and a REST endpoint for discovery.

Modular plugin architecture
Built-in Hello Protocol support
WebSocket and HTTP endpoints
JSON-RPC protocol handling

📱

Client Tools

Multiple client implementations to connect AI systems to MCPI services, including a command-line tool and Chrome extension.

DNS-based service discovery
Rust command-line client
Chrome extension for browser integration
WebSocket communication libraries

🛠️

Development Libraries

Shared libraries to facilitate building both clients and servers with consistent protocol handling.

Common type definitions
Protocol serialization/deserialization
Plugin framework
JSON data handling utilities

Architecture

The MCPI toolkit is organized into several Rust crates that work together to implement the protocol:

mcpi-server

The Rust-based server component that provides MCP protocol endpoints and implements the plugin system.

WebSocket API for MCP protocol
HTTP API for service discovery
Plugin-based architecture
Hello Protocol implementation

mcpi-client

Command-line client that connects to MCPI servers for testing and integration.

DNS-based service discovery
WebSocket communication
Tool execution and testing
Automatic parameter generation

mcpi-common

Shared library used by both server and client components to ensure protocol consistency.

Protocol type definitions
Plugin trait definitions
JSON data handling
Serialization utilities

chrome-extension

Browser extension that provides a user-friendly interface for interacting with MCPI services.

Automatic service detection
Visual WebSocket client
Tool/resource exploration
Quick action execution

Server Architecture

The server is built using a plugin-based architecture that allows for modular capability implementations:

Core server framework handles WebSocket and HTTP connections
Plugin registry manages available capabilities
Each capability is implemented as a separate plugin
JSON data capabilities provide standard CRUD operations
Hello Protocol implemented as a core plugin

Client Architecture

The client tools provide various ways to connect to MCPI services:

DNS-based discovery for finding MCPI-enabled websites
WebSocket communication for real-time interaction
JSON-RPC protocol for remote procedure calls
Testing capabilities for validating implementations
Browser integration via Chrome extension

Server Components

The MCPI server provides a complete implementation of the protocol that you can run for your website or service. Key components include:

Core Server

The main server component provides WebSocket endpoints for MCP protocol communication and REST endpoints for discovery. Built with Axum, it offers excellent performance and reliability.

Plugin System

The server uses a flexible plugin architecture that allows you to extend functionality without modifying core code:

Built-in Plugins: Store, Website, Hello, Social, and Weather plugins
Custom Plugins: Create your own plugins by implementing the McpPlugin trait
Data-Driven: Most plugins can be configured via JSON data files

Hello Protocol Support

The server includes built-in support for the Hello Protocol, our innovative extension that allows AI agents to efficiently understand your website's capabilities without having to parse entire pages.

Simply configure your hello_config.json file with appropriate introductions and context-specific information to dramatically reduce token usage and improve AI understanding of your site. Learn more about the Hello Protocol →

Getting Started with the Server

To run the MCPI server:

$ git clone https://github.com/McSpidey/mcpi
$ cd mcpi
$ cargo run -p mcpi-server

For complete details on configuring and extending the server, please refer to the GitHub repository.

Client Tools

MCPI provides multiple client implementations to fit different usage scenarios:

Command-Line Client

The mcpi-client is a Rust-based command-line tool for interacting with MCPI services. It supports:

DNS-based discovery of MCPI services
Direct connection to known endpoints
Testing specific plugins and operations
Automatic operation parameter generation

Example command-line usage:

$ cargo run -p mcpi-client -- --domain example.com          # Discover via DNS
$ cargo run -p mcpi-client -- --url ws://example.com/mcpi   # Connect directly
$ cargo run -p mcpi-client -- --plugin weather_forecast     # Test specific plugin

For more details on the command-line client, see the README.md file in the repository.

Chrome Extension

The MCPI Chrome Extension provides a user-friendly interface for discovering and interacting with MCP-compliant websites directly from your browser. It automatically detects MCPI services and provides a consistent interface for all MCP operations, including our Hello Protocol extension.

Key Features

Automatic Detection: Automatically detects websites with MCPI support via DNS TXT records
Visual Indicators: Shows green icon when MCPI is available, gray when not
Zero-Click Connection: Automatically connects to MCPI services when the popup is opened
Quick Actions: Pre-configured example queries for each capability
Tool Explorer: Browse and use all available tools, resources, and capabilities

Extension Interface

The extension provides a clean, intuitive interface for working with MCPI services:

Capabilities Tab: View all available capabilities on the site
Tools Tab: Explore and execute tools with pre-configured examples
Resources Tab: Browse available resources from the service
Referrals Tab: See relationships with other MCPI services

Installing the Chrome Extension

Open Chrome Extensions Page: Type chrome://extensions in your address bar
Enable Developer Mode: Toggle on "Developer mode" in the top right corner
Load the Extension: Click "Load unpacked" and select the chrome-extension folder from the repository
Test the Extension: Visit an MCPI-enabled website (or run the local server) and click the extension icon

Using the Chrome Extension

Once installed, the extension icon will turn green when you visit a site with MCPI support. Click the icon to:

See site introduction and capabilities
Browse available tools and resources
Execute quick actions for common operations
Test custom tool parameters

Extension Architecture

The extension is built with modern web technologies:

Background Script: Handles DNS detection and WebSocket communication
Popup Interface: Provides the user interface for interacting with MCPI services
WebSocket Client: Implements the MCP protocol for real-time communication
Tool Executor: Dynamically generates tool interfaces based on server capabilities

For developers, the extension codebase provides an excellent example of how to implement MCPI client functionality in JavaScript.

Integrating MCPI Into Your Projects

There are multiple ways to integrate MCPI into your own projects:

DNS Integration

Add MCPI discovery to your domain by adding a TXT record:

_mcp.example.com IN TXT "v=mcp1 url=https://api.example.com/mcpi/discover"

API Integration

Implement the MCPI API endpoints in your existing API:

GET /mcpi/discover      # Discovery endpoint
WebSocket /mcpi          # MCP protocol endpoint

Plugin Development

Create custom plugins for the MCPI server:

impl McpPlugin for MyPlugin {
    fn name(&self) -> &str { "my_plugin" }
    // Implement required methods...
}

For detailed integration instructions, see the documentation in the GitHub repository.

Next Steps

For Developers

Clone the GitHub repository
Run the server locally to experiment with the protocol
Install the Chrome extension for browser-based testing
Create your own plugins to extend functionality
Add MCPI support to your own websites and services

For Website Owners

Add MCPI DNS records to your domain
Deploy the MCPI server with your site's data
Configure the Hello Protocol with your site's introduction
Create custom plugins for your specific functionality
Test with the Chrome extension and command-line client

Get Started on GitHub Explore Hello Protocol

MCPI Development Tools

Development Tools Overview

Server Components

Client Tools

Development Libraries

Architecture

mcpi-server

mcpi-client

mcpi-common

chrome-extension

Server Architecture

Client Architecture

Server Components

Core Server

Plugin System

Hello Protocol Support

Getting Started with the Server

Client Tools

Command-Line Client

Chrome Extension

Key Features

Extension Interface

Installing the Chrome Extension

Using the Chrome Extension

Extension Architecture

Integrating MCPI Into Your Projects

Next Steps

For Developers

For Website Owners