# 📚 MCP Rust Documentation Parser Server

![MCP](https://img.shields.io/badge/MCP-Compatible-brightgreen)
![Rust](https://img.shields.io/badge/language-Rust-orange)
![License](https://img.shields.io/badge/license-MIT-blue)
![Status](https://img.shields.io/badge/status-experimental-yellow)

A Model Context Protocol (MCP) server that parses Rust project documentation and extracts detailed information about requested items, communicating over stdio transport.

## ✨ Features

- 🔍 **Parse Rust Documentation**: Generate markdown documentation from Rust libraries
- 🧩 **Extract Item Details**: Find and extract specific items (functions, structs, enums) from the documentation
- 🔄 **Stdio Transport**: Simple and efficient communication using standard input/output
- 🛠️ **MCP Compatible**: Fully compliant with the Model Context Protocol specification
- 📊 **Async Processing**: Built with Tokio for efficient asynchronous operations

## 🚀 Installation

### Prerequisites

- Rust and Cargo (latest stable version)
- For documentation generation: `rustdoc-json` and `rustdoc-md` tools

### Setup

1. Clone the repository:

```bash
git clone https://github.com/yourusername/mcp-rs.git
cd mcp-rs
```

2. Build the project:

```bash
cargo build
```

## 🔧 Usage

### Running the Server

```bash
cargo run --bin doc_parser_server
```

### Testing with MCP Inspector

The server can be tested using the [MCP Inspector](https://github.com/modelcontextprotocol/inspector) tool:

```bash
# Install and run the MCP Inspector
RUST_LOG=debug npx @modelcontextprotocol/inspector cargo run --bin doc_parser_server

# In another terminal, run the server
cargo run --bin doc_parser_server
```

Then open the Inspector at http://localhost:6274 and connect to your server using:
- Transport Type: STDIO
- Command: cargo
- Arguments: run --bin doc_parser_server

### API

The server exposes the following MCP tool:

#### `parse_docs`

Parses Rust project documentation and extracts information about a specific item.

**Parameters:**
- `project_path`: Path to the Rust project
- `library`: Name of the library to parse
- `item`: Name of the item to find (function, struct, enum, etc.)

**Returns:**
- Detailed information about the requested item, including documentation, signature, and other metadata

## 🏗️ Architecture

The server is built with the following components:

- **doc_parser_server.rs**: Main server implementation with MCP protocol handling
- **doc_generator.rs**: Generates markdown documentation from Rust projects
- **doc_item_finder.rs**: Extracts specific items from the generated documentation

## 📦 Dependencies

- `rmcp`: Rust implementation of the MCP protocol
- `tokio`: Asynchronous runtime
- `tracing`: Logging and diagnostics
- `serde` and `serde_json`: JSON serialization/deserialization
- `regex`: Pattern matching for documentation parsing
- `anyhow` and `thiserror`: Error handling

## 🧪 Testing

### Manual Testing

1. Start the server:
```bash
cargo run --bin doc_parser_server
```

2. Use MCP Inspector to send requests and view responses:
```bash
npx @modelcontextprotocol/inspector cargo run --bin doc_parser_server
```

3. Open http://localhost:6274 and use the Tools tab to test the `parse_docs` tool

### Automated Testing

Run the test suite:

```bash
cargo test
```

## 🤝 Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

1. Fork the repository
2. Create your feature branch (`git checkout -b feature/amazing-feature`)
3. Commit your changes (`git commit -m 'Add some amazing feature'`)
4. Push to the branch (`git push origin feature/amazing-feature`)
5. Open a Pull Request

## 📄 License

This project is licensed under the MIT License - see the LICENSE file for details.

## 🙏 Acknowledgments

- [Model Context Protocol](https://modelcontextprotocol.io/) for the protocol specification
- [Rust MCP SDK](https://github.com/modelcontextprotocol/rust-sdk) for the Rust implementation of the MCP protocol