MCP DocGen Examples

import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import {
  ListResourcesRequestSchema,
  ReadResourceRequestSchema,
  ListToolsRequestSchema,
  CallToolRequestSchema,
} from "@modelcontextprotocol/sdk/types.js";

/**
 * File Management MCP Server
 * Provides file system operations for LLM applications
 */
const server = new Server(
  {
    name: "file-manager-server",
    version: "1.0.0",
    description: "Secure file system operations for AI applications"
  },
  {
    capabilities: {
      resources: {},
      tools: {},
      prompts: {}
    }
  }
);

// Resource handlers for file listing
server.setRequestHandler(ListResourcesRequestSchema, async () => {
  return {
    resources: [
      {
        uri: "file://documents",
        name: "Documents Directory",
        mimeType: "text/plain",
        description: "Access to user documents"
      }
    ]
  };
});

// Tool for reading files
server.setRequestHandler(ListToolsRequestSchema, async () => {
  return {
    tools: [
      {
        name: "read_file",
        description: "Read contents of a text file",
        inputSchema: {
          type: "object",
          properties: {
            path: {
              type: "string",
              description: "Path to the file to read"
            }
          },
          required: ["path"]
        }
      },
      {
        name: "list_directory",
        description: "List files in a directory",
        inputSchema: {
          type: "object",
          properties: {
            path: {
              type: "string",
              description: "Directory path to list"
            }
          },
          required: ["path"]
        }
      }
    ]
  };
});

async function main() {
  const transport = new StdioServerTransport();
  await server.connect(transport);
  console.error("File Manager MCP Server running on stdio");
}

main();

#!/usr/bin/env python3
"""
Data Analytics MCP Server
Provides data analysis tools for CSV files and datasets
"""

import asyncio
import pandas as pd
from mcp.server import Server
from mcp.server.stdio import stdio_server
from mcp.types import (
    Resource,
    Tool,
    TextContent,
    ImageContent,
    EmbeddedResource,
)

class DataAnalyzer:
    """MCP Server for data analysis operations"""
    
    def __init__(self):
        self.server = Server("data-analyzer")
        self.setup_handlers()
    
    def setup_handlers(self):
        """Configure MCP request handlers"""
        
        @self.server.list_resources()
        async def list_resources() -> list[Resource]:
            """List available data resources"""
            return [
                Resource(
                    uri="data://uploads",
                    name="Uploaded Datasets",
                    mimeType="text/csv",
                    description="User-uploaded CSV files for analysis"
                )
            ]
        
        @self.server.list_tools()
        async def list_tools() -> list[Tool]:
            """List available analysis tools"""
            return [
                Tool(
                    name="analyze_csv",
                    description="Perform statistical analysis on CSV data",
                    inputSchema={
                        "type": "object",
                        "properties": {
                            "file_path": {
                                "type": "string",
                                "description": "Path to CSV file"
                            },
                            "analysis_type": {
                                "type": "string",
                                "enum": ["summary", "correlation", "distribution"],
                                "description": "Type of analysis to perform"
                            }
                        },
                        "required": ["file_path", "analysis_type"]
                    }
                ),
                Tool(
                    name="create_visualization",
                    description="Generate charts and plots from data",
                    inputSchema={
                        "type": "object",
                        "properties": {
                            "data_source": {"type": "string"},
                            "chart_type": {
                                "type": "string",
                                "enum": ["bar", "line", "scatter", "histogram"]
                            },
                            "x_column": {"type": "string"},
                            "y_column": {"type": "string"}
                        },
                        "required": ["data_source", "chart_type"]
                    }
                )
            ]
        
        @self.server.call_tool()
        async def call_tool(name: str, arguments: dict) -> list[TextContent]:
            """Execute analysis tools"""
            if name == "analyze_csv":
                return await self.analyze_csv(**arguments)
            elif name == "create_visualization":
                return await self.create_visualization(**arguments)
            else:
                raise ValueError(f"Unknown tool: {name}")
    
    async def analyze_csv(self, file_path: str, analysis_type: str):
        """Perform CSV analysis"""
        # Implementation would go here
        return [TextContent(
            type="text",
            text=f"Analysis results for {file_path} ({analysis_type})"
        )]

async def main():
    analyzer = DataAnalyzer()
    async with stdio_server() as (read_stream, write_stream):
        await analyzer.server.run(read_stream, write_stream)

if __name__ == "__main__":
    asyncio.run(main())

# Generate and deploy to GitHub Pages
mcp-docgen generate ./my-server --output ./docs
mcp-docgen deploy --platform github-pages --source ./docs

# Or in one command
mcp-docgen deploy --platform github-pages --generate ./my-server

# Custom branch deployment
mcp-docgen deploy --platform github-pages \
  --branch gh-pages \
  --message "Update documentation"