open-index/open-npm huggingface dataset:
npm package: @iflow-mcp/pxnt-chart-v2
Description: A Model Context Protocol server for generating charts using recharts, with SVG output
Latest version: 1.0.0

# MCP Chart Server v2 (Node v20.19.2 Fix)

This is a fixed version of the MCP Chart Server to work with Node.js v20.19.2. The original version had issues with ESM module loading in newer Node.js versions, causing an internal assertion error.

## Fixed Issues

The following issues were fixed:

1. Updated dynamic imports to use `file://` URL protocol with absolute paths
2. Added `.js` extensions to all imports for proper ESM resolution
3. Added file path utilities (`fileURLToPath`, `dirname`, `resolve`) for proper module resolution
4. Removed dynamic import in main index.ts file to avoid ESM loading issues

## How to Use

### Prerequisites

- Node.js v20.19.2 (as specified in package.json)

### Installation

```bash
npm install
```

### Build

```bash
npm run build
```

### Run

```bash
npm run start
```

## Testing the Server

You can test the server using:

```bash
npm run simple-server
```

Or with the example:

```bash
npm run example
```

## If You Still Encounter Issues

If you still encounter ESM module loading issues, you can run the fix script:

```bash
chmod +x fix-esm-imports.sh
./fix-esm-imports.sh
npm run build
```

## Using with LibreChat

This fixed version should now work correctly when integrated with LibreChat using Node.js v20.19.2.
npm package: @iflow-mcp/qasphere-mcp
Description: MCP server for QA Sphere integration
Author: Hypersequent
Latest version: 0.3.0

# QA Sphere MCP Server

A [Model Context Protocol](https://github.com/modelcontextprotocol) server for the [QA Sphere](https://qasphere.com/) test management system.

This integration enables Large Language Models (LLMs) to interact directly with QA Sphere test cases, allowing you to discover, summarize, and chat about test cases. In AI-powered IDEs that support MCP, you can reference specific QA Sphere test cases within your development workflow.

## Prerequisites

- Node.js (recent LTS versions)
- QA Sphere account with API access
- API key from QA Sphere (Settings ⚙️ → API Keys → Add API Key)
- Your company's QA Sphere URL (e.g., `example.eu2.qasphere.com`)

## Setup Instructions

This server is compatible with any MCP client. Configuration instructions for popular clients are provided below.

### Claude Desktop

1. Navigate to `Claude` → `Settings` → `Developer` → `Edit Config`
2. Open `claude_desktop_config.json`
3. Add the QA Sphere configuration to the `mcpServers` dictionary

### Cursor

#### Option 1: Manual Configuration

1. Go to `Settings...` → `Cursor settings` → `Add new global MCP server`
2. Add the QA Sphere configuration

#### Option 2: Quick Install

Click the button below to automatically install and configure the QA Sphere MCP server:

[![Install MCP Server](https://cursor.com/deeplink/mcp-install-dark.svg)](https://cursor.com/install-mcp?name=qasphere&config=eyJjb21tYW5kIjoibnB4IC15IHFhc3BoZXJlLW1jcCIsImVudiI6eyJRQVNQSEVSRV9URU5BTlRfVVJMIjoieW91ci1jb21wYW55LnJlZ2lvbi5xYXNwaGVyZS5jb20iLCJRQVNQSEVSRV9BUElfS0VZIjoieW91ci1hcGkta2V5In19)

### 5ire

1. Open 'Tools' and press 'New'
2. Complete the form with:
   - Tool key: `qasphere`
   - Command: `npx -y qasphere-mcp`
   - Environment variables (see below)

### Configuration Template

For any MCP client, use the following configuration format:

```json
{
  "mcpServers": {
    "qasphere": {
      "command": "npx",
      "args": ["-y", "qasphere-mcp"],
      "env": {
        "QASPHERE_TENANT_URL": "your-company.region.qasphere.com",
        "QASPHERE_API_KEY": "your-api-key"
      }
    }
  }
}
```

Replace the placeholder values with your actual QA Sphere URL and API key.

## License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

## Support

If you encounter any issues or need assistance, please file an issue on the GitHub repository.
npm package: @iflow-mcp/qckfx_node-debugger-mcp
Description: MCP server for Node.js debugging with process management
Latest version: 1.0.0

# Node.js Debugger MCP Server

An MCP server that provides Node.js debugging capabilities with process management for AI agents.

<a href="https://glama.ai/mcp/servers/@qckfx/node-debugger-mcp">
  <img width="380" height="200" src="https://glama.ai/mcp/servers/@qckfx/node-debugger-mcp/badge" alt="Node.js Debugger Server MCP server" />
</a>

## Features

- **Process Management**: Start/stop Node.js processes with debugging enabled
- **Debugging Tools**: Set breakpoints, step through code, evaluate expressions
- **Inspector Integration**: Connect to Node.js Inspector API
- **AI Agent Friendly**: Designed for long-running debugging sessions

## Installation

1. Build the server:
   ```bash
   npm install
   npm run build
   ```

2. **For Project-Specific Use**: The `.mcp.json` file is already configured in this project

3. **For User-Wide Use**: Add to your global Claude Code configuration:
   ```bash
   claude mcp add --scope user debugger-mcp node /absolute/path/to/debugger-mcp/build/index.js
   ```

4. **For Global Use**: Copy the `.mcp.json` to your projects or add to global config

## Usage with Claude Code

Once configured, you'll have access to these tools in Claude Code:

### Process Management
- `start_node_process` - Launch Node.js scripts with debugging
- `kill_process` - Terminate processes by PID
- `list_processes` - Show all managed processes

### Debugging
- `attach_debugger` - Connect to debug port
- `set_breakpoint` - Set breakpoints with optional conditions
  - **Important**: Use full `file://` URLs for reliable breakpoint hits
  - Example: `file:///Users/you/project/script.js`
- `step_debug` - Step through code (next/step/continue/out)
- `pause_execution` - Manually pause a running process
- `evaluate_expression` - Evaluate expressions in debug context

### Resources
- `debug://session` - Current debug session state
- `debug://processes` - List of managed processes

## Example Usage

1. Start a Node.js process:
   ```
   Use the start_node_process tool with script: "example-app.js"
   ```

2. Attach debugger:
   ```
   Use attach_debugger tool with the port returned from step 1
   ```

3. Set breakpoints and debug:
   ```
   # Set a breakpoint using full file URL
   Use set_breakpoint tool with:
   - file: "file:///absolute/path/to/example-app.js"
   - line: 5
   
   # Control execution
   Use step_debug tool with action: "continue"
   ```

## Key Features

- **Automatic Pause on Start**: Uses `--inspect-brk` flag to pause at first line
- **Full Chrome DevTools Protocol**: Real debugging, not simulation
- **Reliable Breakpoints**: Use `file://` URLs for consistent breakpoint hits
- **Process Management**: Track and manage multiple debugging sessions

## Testing

Test with the included example app:
```bash
node --inspect=9229 example-app.js
```

Then use the MCP tools to debug it!

## Debug the MCP Server

```bash
npm run inspector
```
npm package: @iflow-mcp/qiita-mcp-server
Description: MCP server for Qiita
Author: @2bo
Latest version: 0.1.0

# Qiita MCP Server

A Model Context Protocol (MCP) server for interacting with Qiita, the knowledge-sharing platform for engineers.

[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

## Overview

This package provides a Model Context Protocol (MCP) server that enables AI agents to interact with the Qiita API. It allows for creating, reading, and updating articles on Qiita through standardized MCP tools.

MCP is an open protocol for building AI agents that can use external tools and services. This server implements the MCP specification to provide tools for working with Qiita content.

## Provided Tools

The server provides the following MCP tools:

| Tool Name | Description |
|-----------|-------------|
| `get_my_qiita_articles` | Get current authenticated user's Qiita articles |
| `get_qiita_item` | Get a specific Qiita article by its ID |
| `post_qiita_article` | Create a new article on Qiita |
| `update_qiita_article` | Update an existing Qiita article |
| `get_qiita_markdown_rules` | Get Qiita markdown syntax rules and cheat sheet |

## Usage

### Prerequisites

- Node.js (>=20.0.0)
- A Qiita account with API access token
  - You can generate a Qiita API token by visiting: https://qiita.com/settings/tokens/new

### Usage with VS Code

1. Create a `.vscode/mcp.json` file in your project with the following content:

```json
{
  "inputs": [
    {
      "type": "promptString",
      "id": "qiita-api-token",
      "description": "Qiita API Token",
      "password": true
    }
  ],
  "servers": {
    "qiita-mcp-server": {
      "type": "stdio",
      "command": "npx",
      "args": ["@2bo/qiita-mcp-server"],
      "env": {
        "QIITA_API_TOKEN": "${input:qiita-api-token}"
      }
    }
  }
}
```

## Development

### Setup

1. Clone the repository:

```bash
git clone https://github.com/2bo/qiita-mcp-server.git
cd qiita-mcp-server
```

2. Install dependencies:

```bash
npm install
```

3. Set up your environment:

- `npm run dev` - Run TypeScript in watch mode for development
- `npm run build` - Build the project
- `npm run prepare` - Prepare the package for publishing

### Contributing

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

## License

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