How do I use README Generator MCP Server?

1. Click on "Install Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@README Generator MCP Server generate a README for my Node.js project in the current directory" That's it! The server will respond to your query, and you can continue using it as needed. Here is a step-by-step guide with screenshots.

README Generator MCP Server

by JojoSlice

Overview Schema Related Servers Score Discussions

JavaScript

Local

README Generator MCP Server

Version License Node.js TypeScript

📝 Description

A Model Context Protocol (MCP) server that enables LLMs to automatically analyze project structures and generate comprehensive, well-formatted README files. This server provides intelligent project analysis, technology detection, and README generation capabilities that help developers quickly create professional documentation.

Related MCP server: gitSERVER README Manager

🛠️ Technologies Used

Node.js
TypeScript
MCP SDK (@modelcontextprotocol/sdk)

✨ Features

Automatic Technology Detection: Identifies Node.js, TypeScript, Python, Rust, Go, Java, Docker, and more
Smart Project Analysis: Extracts metadata from package.json, dependencies, scripts, and configuration files
Directory Structure Scanning: Recursive traversal with configurable depth and intelligent ignore patterns
Rich README Generation: Creates professional READMEs with badges, emojis, proper sections, and code blocks
Flexible Template System: Predefined structure with required and optional sections
Multi-language Support: Works with various programming languages and frameworks

📦 Installation

npm install

🔧 Setup

1. Build the server

npm run build

2. Configure Claude Desktop

Add this server to your Claude Desktop configuration file:

macOS: ~/Library/Application Support/Claude/claude_desktop_config.json Windows: %APPDATA%\Claude\claude_desktop_config.json Linux: ~/.config/Claude/claude_desktop_config.json

{
  "mcpServers": {
    "readme-generator": {
      "command": "node",
      "args": ["/absolute/path/to/mcp/build/index.js"]
    }
  }
}

3. Restart Claude Desktop

After adding the configuration, restart Claude Desktop to load the MCP server.

Claude Code CLI

To add this MCP server to Claude Code CLI:

# With node (after build)
claude mcp add readme-generator --scope user -- node <path-to-project>/build/index.js

# With npx and TypeScript (development mode)
claude mcp add readme-generator --scope user -- npx -y tsx <path-to-project>/src/index.ts

Replace <path-to-project> with the absolute path to this MCP server.

Scope options:

--scope user: Available in all your projects (recommended)
--scope project: Shared with everyone in the project via .mcp.json
--scope local: Only for the current project

Useful commands:

claude mcp list                    # Show all configured servers
claude mcp remove readme-generator # Remove the server
/mcp                              # Show server status in Claude Code

Gemini CLI

To add this MCP server to Gemini CLI, edit the configuration file:

File location: ~/.config/gemini/settings.json

Add the server configuration:

{
  "mcpServers": {
    "readme-generator": {
      "command": "node",
      "args": ["<path-to-project>/build/index.js"]
    }
  }
}

Replace <path-to-project> with the absolute path to this MCP server.

Alternative with TypeScript (development mode):

{
  "mcpServers": {
    "readme-generator": {
      "command": "npx",
      "args": ["-y", "tsx", "<path-to-project>/src/index.ts"]
    }
  }
}

🚀 Usage

Available Scripts

npm run build

Compiles TypeScript and makes the output executable

npm run watch

Watches for changes and recompiles automatically

npm run prepare

Runs build automatically before npm publish

Available MCP Tools

The server provides four tools for LLMs:

1. `read_project_structure`

Reads the directory structure of a project and returns a tree-like structure.

Example:

{
  "path": "/home/user/my-project",
  "maxDepth": 3
}

2. `read_file`

Reads the contents of a specific file.

Example:

{
  "path": "/home/user/my-project/package.json"
}

3. `analyze_project`

Analyzes a project directory and returns structured data including detected technologies, dependencies, scripts, and directory structure.

Example:

{
  "projectPath": "/home/user/my-project"
}

4. `generate_readme`

Automatically generates a complete, professional README.md file for a project.

Example:

{
  "projectPath": "/home/user/my-project"
}

💡 Usage Examples

Quick README Generation

Once the MCP server is configured in Claude Desktop, simply ask:

"Generate a README for my project at /home/user/my-awesome-app"

The server will:

Analyze the project directory
Detect technologies (Node.js, Python, Rust, etc.)
Extract metadata from configuration files
Generate a professional README with appropriate sections

Detailed Project Analysis

For more control over the process:

"Analyze the project at /home/user/my-awesome-app and show me what you found"

Review the analysis, then request:

"Now generate a README emphasizing the API documentation and deployment sections"

Step-by-Step Workflow

For complex projects requiring customization:

Explore the structure:

"Read the project structure of /home/user/my-app with depth 4"

Review specific files:

"Read the package.json and show me the available scripts"

Get comprehensive analysis:

"Analyze the entire project and tell me what technologies you detected"

Generate customized README:

"Create a README with extra focus on the testing and contribution guidelines"

Real-World Example

User: "I have a TypeScript Express API project at /home/user/projects/api-server.
       Can you create a README for it?"

Claude: [Uses the MCP server to analyze the project]
        "I've analyzed your project and found:
        - TypeScript with Express.js
        - PostgreSQL database integration
        - Jest for testing
        - Docker configuration

        I'll create a comprehensive README with sections for setup,
        API endpoints, database configuration, and deployment."

The generated README will automatically include:

Proper badges for TypeScript, Node.js, etc.
Installation instructions based on package.json
All available npm scripts with descriptions
Project structure visualization
Dependencies and dev dependencies
API usage examples (if detected)
Docker deployment instructions (if Dockerfile exists)

📁 Project Structure

mcp/
  package-lock.json
  package.json
  src/
    index.ts
  tsconfig.json

🎨 Customization

Modify the README Template

Edit the README_TEMPLATE in src/index.ts:12-66 to customize sections:

const README_TEMPLATE = {
  sections: [
    {
      name: "Project Title",
      description: "The main title/name of the project",
      required: true,
    },
    {
      name: "Your Custom Section",
      description: "Description of what this section should contain",
      required: false,
    },
    // Add more sections as needed
  ],
};

Add Technology Detection

Extend the analyzeProject function in src/index.ts:126-214 to detect additional frameworks:

if (files.includes("docker-compose.yml")) {
  detectedTechnologies.push("Docker Compose");
  configFiles.push("docker-compose.yml");
}

After making changes, rebuild:

npm run build

📚 Dependencies

@modelcontextprotocol/sdk

🔧 Dev Dependencies

@types/node
typescript

📖 How It Works

Project Scanning: Recursively reads the project directory (ignoring node_modules, .git, dist, build)
Technology Detection: Identifies technologies based on config files (package.json, tsconfig.json, Cargo.toml, etc.)
Metadata Extraction: Pulls information from package.json including scripts, dependencies, author, license
Template Application: Uses a predefined template structure with required and optional sections
README Generation: Creates a formatted README with badges, proper sections, code blocks, and professional styling

🤝 Contributing

Contributions are welcome! To contribute:

Fork the repository
Create a feature branch: git checkout -b feature/my-feature
Make your changes and test them
Commit your changes: git commit -m 'Add my feature'
Push to the branch: git push origin feature/my-feature
Submit a pull request

📄 License

This project is licensed under the ISC License.

This README was generated using the README Generator MCP Server itself! 🎉

Available Tools

4 tools

analyze_projectA

Analyze a project directory and return structured data about the project along with a README template. Returns: (1) A template structure with recommended README sections (some required, some optional), and (2) Detailed project analysis including detected technologies, package.json data, directory structure, scripts, dependencies, and configuration files. The LLM should use this information to construct a comprehensive README following the template structure as a guide, adapting sections based on what's relevant for the specific project.

ParametersJSON Schema

Name	Required	Description	Default
`projectPath`	Yes	The absolute path to the project directory

TDQS

A3.9/5.0

Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries full burden. It discloses the tool's behavior by describing what it returns (structured data and README template) and how the LLM should use the output. However, it doesn't mention potential limitations like file size constraints, processing time, error conditions, or authentication requirements.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is appropriately sized and front-loaded, starting with the core functionality. Most sentences earn their place by explaining the output and usage guidance, though the final sentence about LLM adaptation could be slightly more concise.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's complexity (analyzing entire projects) and lack of output schema, the description does well by detailing the two main return components and their contents. It explains how the output should be used, though it could benefit from mentioning error scenarios or performance characteristics for a more complete picture.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the schema already documents the single parameter 'projectPath' as an absolute path. The description doesn't add any parameter-specific information beyond what's in the schema, such as path format examples or validation rules. Baseline 3 is appropriate when schema does the documentation work.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's purpose with specific verbs ('analyze', 'return') and resources ('project directory', 'structured data', 'README template'). It distinguishes from sibling tools like 'generate_readme' by focusing on analysis rather than generation, and from 'read_project_structure' by providing comprehensive analysis beyond just structure.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides clear context for when to use this tool: to analyze a project directory and obtain structured data and a README template. It implicitly suggests using 'generate_readme' for actual README generation, but doesn't explicitly state when NOT to use this tool or compare alternatives in detail.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

generate_readmeB

Generate a well-formatted, visually appealing README.md file for a project. This tool analyzes the project directory and automatically creates a comprehensive README with: badges, emojis, proper sections (description, installation, usage, project structure, dependencies, etc.), code blocks, and professional formatting. The generated README is ready to use and follows best practices.

ParametersJSON Schema

Name	Required	Description	Default
`projectPath`	Yes	The absolute path to the project directory

TDQS

B3.4/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries full burden but lacks key behavioral details: it doesn't specify if the tool overwrites existing README files, what permissions are needed, error handling, or output format. It mentions 'analyzes the project directory' but doesn't explain how this analysis works.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is appropriately sized and front-loaded, starting with the core function. All sentences contribute value, though it could be slightly more concise by combining some details about README content.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a tool with no annotations, no output schema, and one parameter, the description is adequate but incomplete: it covers what the tool does but lacks behavioral context and doesn't explain what 'ready to use' means in practice (e.g., file creation location, format specifics).

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the schema already documents the single parameter 'projectPath'. The description adds no additional parameter semantics beyond what's in the schema, maintaining the baseline score.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's purpose with specific verbs ('generate', 'analyzes', 'creates') and resources ('README.md file for a project'), and distinguishes it from siblings by focusing on automated documentation generation rather than analysis or reading functions.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies usage for creating project documentation but doesn't explicitly state when to use this tool versus alternatives like 'analyze_project' or 'read_project_structure'. No exclusions or prerequisites are mentioned.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

read_fileC

Read the contents of a file

ParametersJSON Schema

Name	Required	Description	Default
`path`	Yes	The absolute path to the file to read

TDQS

C2.9/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries full burden for behavioral disclosure. While 'Read' implies a read-only operation, it doesn't specify permissions required, file size limits, encoding handling, error conditions, or what happens with binary files. This leaves significant gaps for a tool that interacts with the filesystem.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is perfectly concise at just 5 words: 'Read the contents of a file'. Every word earns its place, with no wasted language or unnecessary elaboration. It's front-loaded with the core action and resource.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a filesystem tool with no annotations and no output schema, the description is insufficient. It doesn't address critical context like return format (text, binary, encoding), error handling, permissions, or limitations. The agent would need to guess about important behavioral aspects of file reading.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The schema description coverage is 100%, with the single parameter 'path' clearly documented in the schema as 'The absolute path to the file to read'. The description adds no additional parameter information beyond what's already in the schema, so the baseline score of 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the verb ('Read') and resource ('contents of a file'), making the purpose immediately understandable. It doesn't specifically differentiate from sibling tools like 'read_project_structure' or 'analyze_project', but the action is unambiguous for a file-reading operation.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives like 'read_project_structure' or 'analyze_project'. It doesn't mention any prerequisites, limitations, or specific contexts where this tool is preferred over other file-related operations.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

read_project_structureB

Read the directory structure of a project. Returns a tree-like structure of files and folders.

ParametersJSON Schema

Name	Required	Description	Default
`path`	Yes	The absolute path to the project directory
`maxDepth`	No	Maximum depth to traverse (default: 3)

TDQS

B3.3/5.0

Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool reads and returns a tree-like structure, which implies it's a read-only operation, but doesn't cover aspects like error handling (e.g., if the path doesn't exist), performance considerations, or any side effects. It adds basic context but lacks depth for a tool with no annotation support.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is highly concise and front-loaded: two sentences that directly state the action and output without unnecessary words. Every sentence earns its place by conveying essential information efficiently.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's moderate complexity (2 parameters, no output schema, no annotations), the description is minimally complete. It covers the basic purpose and output but lacks details on usage guidelines, behavioral traits, and error handling. With no output schema, it should ideally explain return values more thoroughly, but it only mentions 'tree-like structure' vaguely.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the schema already documents both parameters ('path' and 'maxDepth') with descriptions. The description doesn't add any parameter-specific details beyond what the schema provides, such as format examples or constraints. Baseline 3 is appropriate when the schema handles parameter documentation adequately.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's purpose: 'Read the directory structure of a project' specifies the verb (read) and resource (directory structure), and 'Returns a tree-like structure of files and folders' clarifies the output. However, it doesn't explicitly differentiate from sibling tools like 'analyze_project' or 'read_file', which might have overlapping functionality.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention when to choose 'read_project_structure' over 'analyze_project' or 'read_file', nor does it specify prerequisites or exclusions. Usage is implied only by the purpose statement.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Install Server

RayrunBuild, deploy, and operate MCP servers without becoming an infrastructure team.ray.runAd

TDQS

B3.1/5.0

Disambiguation2/5

Multiple tools have unclear boundaries, particularly analyze_project and generate_readme, which both analyze the project directory and generate README-related outputs, causing potential confusion. While read_file and read_project_structure are more distinct, the overlap between the first two tools is significant and could lead to misselection.

Naming Consistency4/5

The tool names follow a mostly consistent verb_noun pattern (e.g., analyze_project, generate_readme, read_file, read_project_structure), with only minor deviations in verb choice. This consistency aids in readability and predictability across the set.

Tool Count3/5

With 4 tools, the count is borderline for the server's purpose of README generation; it feels thin as it lacks operations like updating or deleting READMEs, and the overlap between tools suggests redundancy rather than comprehensive coverage. A well-scoped set for this domain might include more distinct actions.

Completeness2/5

There are significant gaps in the tool surface for README generation, such as missing update or delete operations for README files, and no tools for validating or customizing READMEs beyond generation. The overlap between analyze_project and generate_readme further indicates incomplete coverage, as agents may struggle with dead ends in workflows.

Maintenance

ActivityInactive

ResponsivenessSyncing

Resources

GitHub Repository

Need Help?

Related Servers

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Related MCP Connectors

searchcode A
com.searchcode
Code intelligence for LLMs. Analyze, search, and retrieve code from any public git repository.
Search Code Analysis Version Control
62
docfork-mcp
ai.smithery
@latest documentation and code examples to 9000+ libraries for LLMs and AI code editors in a singl…
Documentation Access Developer Tools Code Analysis
2488
AI Readiness Kit A
io.github.silverbackmarketing
Generate 18 AI readiness files (llms.txt, ai.txt, RAG indexes, schema) for any website.
RAG Systems Search Knowledge & Memory
623
llmref A
org.llmref
Versioned documentation registry and semantic search for AI tools and coding assistants.
Documentation Access Search Developer Tools
42

Related MCP Servers

PRD Generator MCP Server
Njengah
F
license
B
quality
C
maintenance
Reads README files from the file system and automatically generates structured Product Requirements Documents (PRDs), saving users time on documentation tasks.
Updated a year ago (2025-07-10 16:07 UTC)
1
9
gitSERVER README Manager
Developer Tools Documentation Access File Systems
rudra-pratapsingh
F
license
Not graded
quality
D
maintenance
Enables automated README file management for development projects through MCP tools for content creation and summarization, resources for direct file access, and prompts for AI-powered documentation analysis.
Updated a year ago (2025-09-07 00:50 UTC)
Zhiwen Assistant MCP
Developer Tools Documentation Access App Automation
kscz0000
A
license
Not graded
quality
Not graded
maintenance
Automatically generates Chinese README documentation and mind maps for project folders, enabling intelligent documentation management and project structure visualization.
Updated 8 months ago (2025-12-20 08:38 UTC)
codebase-doc-generator
Developer Tools Code Analysis Documentation Access
lazymac2x
A
license
Not graded
quality
D
maintenance
Generates comprehensive documentation (architecture overview, dependency graph, API surface, and README) for any codebase locally without external APIs.
Updated 5 months ago (2026-03-28 10:47 UTC)
12
1
MIT

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/JojoSlice/README-Gen-MCP-Server'

If you have feedback or need assistance with the MCP directory API, please join our Discord server

README Generator MCP Server

📝 Description

🛠️ Technologies Used

✨ Features

📦 Installation

🔧 Setup

1. Build the server

2. Configure Claude Desktop

3. Restart Claude Desktop

Claude Code CLI

Gemini CLI

🚀 Usage

Available Scripts

Available MCP Tools

1. read_project_structure

2. read_file

3. analyze_project

4. generate_readme

💡 Usage Examples

Quick README Generation

Detailed Project Analysis

Step-by-Step Workflow

Real-World Example

📁 Project Structure

🎨 Customization

Modify the README Template

Add Technology Detection

📚 Dependencies

🔧 Dev Dependencies

📖 How It Works

🤝 Contributing

📄 License

Available Tools

Maintenance

Resources

Looking for Admin?

Related MCP Connectors

Related MCP Servers

Latest Blog Posts

MCP directory API

1. `read_project_structure`

2. `read_file`

3. `analyze_project`

4. `generate_readme`