open-index/open-npm huggingface dataset:
npm package: @iflow-mcp/cqfn-aibolit-mcp-server
Description: MCP Server for Aibolit
Author: Yegor Bugayenko
Latest version: 0.0.1

# MCP Server for Aibolit, Java Code Analyzer

[![DevOps By Rultor.com](https://www.rultor.com/b/cqfn/aibolit-mcp-server)](https://www.rultor.com/p/cqfn/aibolit-mcp-server)

[![make](https://github.com/cqfn/aibolit-mcp-server/actions/workflows/make.yml/badge.svg)](https://github.com/cqfn/aibolit-mcp-server/actions/workflows/make.yml)
[![codecov](https://codecov.io/gh/cqfn/aibolit-mcp-server/graph/badge.svg?token=3dr2Il91wJ)](https://codecov.io/gh/cqfn/aibolit-mcp-server)
[![Hits-of-Code](https://hitsofcode.com/github/cqfn/aibolit-mcp-server)](https://hitsofcode.com/view/github/cqfn/aibolit-mcp-server)
[![License](https://img.shields.io/badge/license-MIT-green.svg)](https://github.com/cqfn/aibolit-mcp-server/blob/master/LICENSE.txt)

If you use AI agents, such as [Claude Code], [Cursor], or [Windsurf],
  for code refactoring, you may enjoy using this [MCP] server.
Your AI agent, when you ask it to "make code better,"
  may wonder what exactly needs to be improved.
Sadly, it may often overlook important problems.
AI agents, by design, pay more attention to cosmetic issues,
  which are "low-hanging fruits" for them.
This [MCP] server will give your agent a hint:
  what is the **most critical design issue** in the code.
Then, the agent will refactor it and fix the issue.

First, install [Node], [Npm], [Python], [Pip], and [aibolit]:

```bash
aibolit --version
```

Then, add this [MCP] server to [Claude Code]
(or simply edit `~/claude.json`, but it's not recommended):

```bash
claude mcp add aibolit npx aibolit-mcp-server@0.0.6
```

Then, restart [Claude Code] and ask it something along these lines:
"Find the most critical design issue in my code base and fix it."

## How to Contribute

To test this project, simply run the following commands
(you'll need [Node] 18+, [Npm], and [GNU make] installed):

```bash
npm install
make
```

If everything builds correctly after your changes, submit a pull request.

[MCP]: https://modelcontextprotocol.io/
[Npm]: https://www.npmjs.com/
[Node]: https://nodejs.org/en
[aibolit]: https://github.com/cqfn/aibolit
[Claude Code]: https://github.com/anthropics/claude-code
[Cursor]: https://www.cursor.com/
[Windsurf]: https://windsurf.com/editor
[GNU make]: https://www.gnu.org/software/make/
[Python]: https://www.python.org/
[Pip]: https://pypi.org/project/pip/
npm package: @iflow-mcp/create-mcp
Description: CLI tool to quickly scaffold new MCP servers
Author: zue
Latest version: 1.0.1

# create-mcp

A CLI tool that sets up a [Model Control Protocol (MCP)](https://modelcontextprotocol.io) server and deploys it to Cloudflare Workers so you can start making new tools for your Cursor Agent in minutes.

> Just write TypeScript functions with JSDoc comments to give your agent MCP tools.

## Prerequisites

- [Wrangler CLI](https://developers.cloudflare.com/workers/wrangler/install-and-update/) installed and logged in with your Cloudflare account.
- Claude Desktop App installed. (This will be removed soon)

## Instructions

To scaffold and deploy a new MCP server, just run:

```bash
bun create mcp
```

You can also pass a name directly to the command: `bun create mcp --name <server-name>`.

## What this CLI does

- Clones the template worker repository into `<current-dir>/<server-name>`
- Installs dependencies
- Initializes a Git repository
- Deploys a Hello World MCP server to your Cloudflare account
- Adds it to Claude Desktop
- Copies the MCP server command to your clipboard so you can paste it into Cursor

## How to Use

Just add functions to the `MyWorker` class in `src/index.ts`. Each function will compile into an MCP tool.

For example:

```typescript
/**
 * A warm, friendly greeting from your new Workers MCP server.
 * @param name {string} the name of the person we are greeting.
 * @return {string} the contents of our greeting.
 */
sayHello(name: string) {
    return `Hello from an MCP Worker, ${name}!`;
}
```

- The first line is the tool's description.
- The `@param` tags are the tool's params, with types and descriptions.
- The `@return` tag is the tool's return value, with its type.

## Deploying Changes

1. Redeploy the worker:

```bash
bun run deploy
```

2. Reload your Cursor window.

Now you can ask your agent to use the new tool!

## Why Cloudflare Workers?

Vibes, great DX, and blazing fast deployments.

I don't like running MCP servers locally, and I'm pretty sure you don't either. Now we don't have to run node processes to use simple MCP tools in Cursor that call APIs.

All you have to do is write functions. Put your descriptions and params in JSDoc comments and it just works.

## Example Servers made with create-mcp

- [Neon](https://github.com/zueai/neon-mcp)
- [Cloudflare](https://github.com/zueai/cloudflare-api-mcp)
- [Vercel](https://github.com/zueai/vercel-api-mcp)
- [WorkOS](https://github.com/zueai/workos-mcp)


You can clone and deploy any MCP server made with create-mcp to your own Cloudflare account:

```bash
bun create mcp --clone <github-url>
```
npm package: @iflow-mcp/cubedevinc-mcp-server
Description: A Model Context Protocol (MCP) server that provides chat functionality with Cube's AI agent for analytics and data exploration
Author: Cube Dev Team
Latest version: 1.3.0

# Cube MCP Server

A Model Context Protocol (MCP) server that provides chat functionality with Cube's AI agent for analytics and data exploration.

## Features

This MCP server provides:

### Tools
- **chat**: Chat with Cube AI agent for analytics and data exploration (streams real-time responses)

## MCP Client Configuration

### Cursor or Claude Desktop Configuration

For Cursor and Claude Desktop, add this to your MCP settings:

#### For Internal Cube Users

```json
{
  "mcpServers": {
    "cube-mcp-server": {
      "command": "npx",
      "args": ["@cube-dev/mcp-server"],
      "env": {
        "CUBE_CHAT_API_URL": "https://ai.{cloudRegion}.cubecloud.dev/api/v1/public/{accountName}/agents/{agentId}/chat/stream-chat-state",
        "CUBE_API_KEY": "your_api_key_here",
        "INTERNAL_USER_ID": "analyst@yourcompany.com"
      }
    }
  }
}
```

#### For External Users

```json
{
  "mcpServers": {
    "cube-mcp-server": {
      "command": "npx",
      "args": ["@cube-dev/mcp-server"],
      "env": {
        "CUBE_CHAT_API_URL": "https://ai.{cloudRegion}.cubecloud.dev/api/v1/public/{accountName}/agents/{agentId}/chat/stream-chat-state",
        "CUBE_API_KEY": "your_api_key_here",
        "EXTERNAL_USER_ID": "user-123"
      }
    }
  }
}
```

#### Obtaining Credentials

* **CUBE_CHAT_API_URL** - Copy the complete Chat API URL from **Admin → Agents → Click on Agent → Chat API URL field**. This is the full endpoint URL for your agent.
* **CUBE_API_KEY** - Navigate to **Admin → API Keys** to obtain your API key.
* **User Identity** (choose one):
  * **INTERNAL_USER_ID** - Email address of an existing Cube user. Use this for internal team members who already have Cube accounts. The user's existing permissions and settings will be used.
  * **EXTERNAL_USER_ID** - A unique identifier for external/third-party users (e.g., "user-123", "customer@external.com"). Use this when you need to provide custom user attributes, groups, or row-level security settings.

## Cube Chat Examples

Ask questions like "Show me revenue trends" or "What are our top products?" to get real-time analytics responses with data visualizations and SQL queries.

## Architecture

Standard MCP server with tools, resources, and stdio transport. Integrates with Cube's streaming chat API using API key authentication and supports two types of user authentication:

- **Internal Users**: Existing Cube users authenticated by their email address. They use their configured permissions and settings from Cube.
- **External Users**: Third-party users with custom identifiers, allowing for dynamic user attributes, groups, and row-level security configuration.

Built with `@modelcontextprotocol/sdk`. The Chat API URL should be copied from your agent settings in the Cube admin panel.
npm package: @iflow-mcp/cuifuze-qwen-dgj-mcp
Description: MCP Server for managing other MCP servers in qwen-code
Author: Your Name
Latest version: 0.1.1

# Qwen MCP Manager

MCP Server for managing other MCP servers in qwen-code.

## Getting Started

```bash
npm install
npm run build
```

## CLI Usage

After installation or via npx:

```bash
# Start the MCP server (stdio)
npx -y qwen-mcp-manager

# Merge MCP servers from a JSON file into ~/.qwen/settings.json
npx -y qwen-mcp-manager apply --file ./mcp.json

# Show help
npx -y qwen-mcp-manager --help
```

JSON example:

```json
{
  "mcpServers": {
    "playwright": {
      "command": "npx",
      "args": ["@playwright/mcp@latest"]
    }
  }
}
```

## Configure in Qwen Code

Use npx (recommended):

```json
{
  "mcpServers": {
    "dgj": {
      "command": "npx",
      "args": ["-y", "qwen-mcp-manager"]
    }
  }
}
```

Or install globally and use the binary:

```json
{
  "mcpServers": {
    "dgj": {
      "command": "qwen-mcp-manager"
    }
  }
}
```

## Development

```bash
npm run dev
```