mcpdoc

🥈Silver

Expose llms-txt to IDEs for development. Enables developers to integrate LLM documentation directly into their IDEs, streamlining the development process. Connects to IDEs like Cursor and Windsurf, and apps like Claude Code/Desktop.

9741100Updated 1mo ago

Intermediate30min to implementautomation

Saves ~50 min per use

Quick InstallView Source

git clone https://github.com/langchain-ai/mcpdoc.git

Works with:

Claude

Overview

About This Skill

The mcpdoc skill is designed to expose llms-txt documentation to integrated development environments (IDEs), facilitating a more efficient coding experience. By integrating llms-txt resources directly into IDEs like Cursor, Windsurf, and Claude Desktop, developers can access vital documentation seamlessly, enhancing their coding assistance and overall productivity. This skill is particularly beneficial for those working in environments where rapid access to accurate documentation is crucial for maintaining workflow efficiency. One of the key benefits of using mcpdoc is the potential for significant time savings during the development process. While specific time savings are currently unknown, the ability to retrieve and audit documentation from multiple llms.txt files means developers can spend less time searching for information and more time focusing on coding. Additionally, setting up a local MCP server allows for testing and validation of llms.txt files before deployment, ensuring that developers can catch issues early in the workflow. This skill is ideal for developers and product managers who are looking to streamline their workflow automation processes. By incorporating mcpdoc into their toolset, teams can ensure that they are working with the most relevant and up-to-date documentation, which is essential for maintaining a competitive edge in AI development. The integration of domain access controls also adds a layer of security, ensuring that documentation is retrieved only from trusted sources, which is critical in sensitive development environments. With an intermediate implementation difficulty and a setup time of approximately 30 minutes, mcpdoc is accessible for teams ready to enhance their AI-first workflows. The skill's integration capabilities allow for a dynamic connection to llms-txt resources, making it a valuable addition to any developer's toolkit. As AI automation continues to evolve, skills like mcpdoc will play a pivotal role in shaping efficient and effective development practices.

How to Use

1. **Install mcpdoc**: Ensure the mcpdoc MCP server is running (e.g., via `mcp-server-mcpdoc` in your terminal). Verify it’s connected to your IDE by checking the MCP server logs for a success message like 'mcpdoc server started on port 8080'. 2. **Load llms-txt file**: In your IDE (e.g., Cursor or Windsurf), open the `llms-txt` file you want to integrate (e.g., `docs/llms-txt/data_processor.txt`). Use the IDE’s MCP panel to select the file and trigger the mcpdoc integration. 3. **Verify integration**: Hover over a function or class in your code (e.g., `DataProcessor.clean_data`) to confirm the documentation appears in the context panel. If not, check the IDE’s MCP server logs for errors like 'Failed to load documentation for [FUNCTION_NAME]'. 4. **Test documentation**: Query a specific function (e.g., 'What are the parameters for `DataProcessor.clean_data`?') and ensure the response is displayed in the IDE. If the response is truncated, adjust the `llms-txt` file to include more detailed examples. 5. **Iterate**: Update the `llms-txt` file with new documentation and refresh the MCP server to propagate changes. Use the IDE’s 'Reload MCP Servers' option to force a refresh.

Use Cases

Integrate llms-txt documentation into Cursor IDE for enhanced coding assistance.

Retrieve and audit documentation from multiple llms.txt files for better context during development.

Set up a local MCP server to test and validate llms.txt files before deployment.

Connect various IDEs like Windsurf and Claude Desktop to access llms-txt resources dynamically.

Setup & Installation

Quick Install

No install command available. Check the GitHub repository for manual installation instructions.

Alternative Install (Git Clone)

git clone https://github.com/langchain-ai/mcpdoc

Requirements

Claude Code or compatible AI agent
Works with: Claude

Quick Start Guide

Install the Skill

Copy the install command above and run it in your terminal.

Open Your AI Agent

Launch Claude Code, Cursor, or your preferred AI coding agent.

Try It Out

Use the prompt template or examples below to test the skill.

Customize

Adapt the skill to your specific use case and workflow.

Usage Examples

Prompt Template

Integrate [LLMS_TXT_FILE_PATH] into [IDE_NAME] using the mcpdoc skill. Verify the documentation is accessible in the IDE's context panel. If errors occur, check the MCP server logs for [SPECIFIC_ERROR]. Once integrated, test the documentation by querying [SPECIFIC_FUNCTION_OR_CLASS] and confirm the response appears in the IDE.

Example Output

Successfully integrated the `llms-txt` documentation for the `DataProcessor` class into Cursor IDE using mcpdoc. The context panel now displays real-time documentation for `DataProcessor.clean_data()` with parameters (`input_path: str`, `output_path: str`, `batch_size: int = 1000`), return type (`DataFrame`), and a concise description of its purpose: 'Cleans and normalizes raw input data for downstream ML pipelines.'

When hovering over `clean_data` in the IDE, the panel shows:
```python
def clean_data(input_path: str, output_path: str, batch_size: int = 1000) -> DataFrame:
    """
    Cleans and normalizes raw input data for downstream ML pipelines.
    
    Args:
        input_path: Path to raw CSV/JSON data.
        output_path: Path to save cleaned data.
        batch_size: Number of rows processed per batch (default: 1000).
    
    Returns:
        DataFrame: Cleaned data ready for feature engineering.
    """
    ...
```

The documentation also includes a usage example:
```python
from data_processor import DataProcessor

processor = DataProcessor()
cleaned_df = processor.clean_data(
    input_path="data/raw/transactions.csv",
    output_path="data/cleaned/transactions.parquet",
    batch_size=5000
)
```

No errors were logged in the MCP server during integration.