open-index/open-npm huggingface dataset:
npm package: @mcpkit-dev/cli
Description: CLI tool for creating and managing mcpkit MCP servers
Latest version: 2.4.1

# @mcpkit-dev/cli

[![npm version](https://img.shields.io/npm/v/@mcpkit-dev/cli.svg)](https://www.npmjs.com/package/@mcpkit-dev/cli)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

CLI tool for creating and managing MCPKit MCP servers.

## Installation

```bash
npm install -g @mcpkit-dev/cli
```

## Quick Start

```bash
# Create a new project
npx @mcpkit-dev/cli init my-server

# Navigate and start development
cd my-server
npm run dev
```

## Commands

### `mcpkit init [name]`

Create a new MCP server project with interactive prompts.

```bash
mcpkit init my-server
```

Options:
- `-t, --template <template>` - Template to use (basic, advanced)
- `--no-git` - Skip git initialization
- `--no-install` - Skip installing dependencies

### `mcpkit dev`

Start the server in development mode with watch and auto-reload.

```bash
mcpkit dev
```

### `mcpkit build`

Build the server for production.

```bash
mcpkit build
```

## Documentation

**[Read the full documentation](https://v-checha.github.io/mcpkit/)**

- [Getting Started](https://v-checha.github.io/mcpkit/docs/getting-started/installation)
- [Quick Start](https://v-checha.github.io/mcpkit/docs/getting-started/quick-start)

## Related Packages

- [@mcpkit-dev/core](https://www.npmjs.com/package/@mcpkit-dev/core) - Core framework
- [@mcpkit-dev/testing](https://www.npmjs.com/package/@mcpkit-dev/testing) - Testing utilities

## License

MIT
npm package: @mcpkit-dev/core
Description: Developer-friendly toolkit for building MCP servers with decorators
Latest version: 2.4.1

# @mcpkit-dev/core

[![npm version](https://img.shields.io/npm/v/@mcpkit-dev/core.svg)](https://www.npmjs.com/package/@mcpkit-dev/core)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

Core framework for building Model Context Protocol (MCP) servers with TypeScript decorators.

## Installation

```bash
npm install @mcpkit-dev/core reflect-metadata zod
```

## Quick Start

```typescript
import 'reflect-metadata';
import { createServer, MCPServer, Tool, Param } from '@mcpkit-dev/core';

@MCPServer({
  name: 'my-server',
  version: '1.0.0',
})
class MyServer {
  @Tool({ description: 'Greet someone' })
  greet(@Param({ name: 'name', description: 'Name to greet' }) name: string) {
    return `Hello, ${name}!`;
  }
}

const server = createServer(MyServer);
await server.listen();
```

## Features

- **Decorators** - `@MCPServer`, `@Tool`, `@Resource`, `@Prompt`, `@Param`
- **Raw tool results** - `@Tool({ rawResult: true })` to return MCP `CallToolResult` directly
- **Authentication** - API key, JWT, Bearer token middleware
- **Observability** - `@Debug`, `@Monitor`, `@Traced` decorators
- **Plugins** - Extensible plugin system with lifecycle hooks
- **Transports** - stdio, HTTP/SSE, Streamable HTTP

## Documentation

**[Read the full documentation](https://v-checha.github.io/mcpkit/)**

- [Getting Started](https://v-checha.github.io/mcpkit/docs/getting-started/installation)
- [Tools Guide](https://v-checha.github.io/mcpkit/docs/guides/tools)
- [Resources Guide](https://v-checha.github.io/mcpkit/docs/guides/resources)
- [Authentication](https://v-checha.github.io/mcpkit/docs/advanced/authentication)
- [Plugins](https://v-checha.github.io/mcpkit/docs/advanced/plugins-guide)
- [Observability](https://v-checha.github.io/mcpkit/docs/observability/overview)
- [API Reference](https://v-checha.github.io/mcpkit/docs/api/decorators)

## Using with Claude Desktop

```json
{
  "mcpServers": {
    "my-server": {
      "command": "node",
      "args": ["/path/to/your/server/dist/index.js"]
    }
  }
}
```

## TypeScript Configuration

```json
{
  "compilerOptions": {
    "experimentalDecorators": true,
    "emitDecoratorMetadata": true,
    "target": "ES2022",
    "module": "NodeNext",
    "moduleResolution": "NodeNext"
  }
}
```

## Related Packages

- [@mcpkit-dev/cli](https://www.npmjs.com/package/@mcpkit-dev/cli) - CLI for project scaffolding
- [@mcpkit-dev/testing](https://www.npmjs.com/package/@mcpkit-dev/testing) - Testing utilities

## License

MIT
npm package: @mcpkit-dev/testing
Description: Testing utilities for mcpkit MCP servers
Latest version: 2.4.1

# @mcpkit-dev/testing

[![npm version](https://img.shields.io/npm/v/@mcpkit-dev/testing.svg)](https://www.npmjs.com/package/@mcpkit-dev/testing)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

Testing utilities for MCPKit MCP servers.

## Installation

```bash
npm install -D @mcpkit-dev/testing
```

## Quick Start

```typescript
import { describe, it, expect, beforeEach, afterEach } from 'vitest';
import { MockMcpClient } from '@mcpkit-dev/testing';
import { bootstrapServer, MetadataStorage } from '@mcpkit-dev/core';
import { MyServer } from './my-server';

describe('MyServer', () => {
  let client: MockMcpClient;
  let cleanup: () => Promise<void>;

  beforeEach(async () => {
    const { client: mockClient, serverTransport } = MockMcpClient.create();
    client = mockClient;

    const instance = new MyServer();
    const options = MetadataStorage.getServerOptions(MyServer);
    const server = await bootstrapServer(instance, options!);
    await server.server.connect(serverTransport);
    await client.connect();

    cleanup = async () => {
      await client.close();
      await server.close();
    };
  });

  afterEach(async () => {
    await cleanup();
  });

  it('should call a tool', async () => {
    const result = await client.callTool('greet', { name: 'World' });
    expect(result.content[0].text).toBe('Hello, World!');
  });
});
```

## Features

- **MockMcpClient** - Full-featured mock MCP client
- **InMemoryTransport** - Zero-latency transport for unit tests
- **Test helpers** - `createTestClient()`, `waitForCondition()`

## API

### MockMcpClient

```typescript
const { client, serverTransport } = MockMcpClient.create();

await client.connect();
await client.listTools();
await client.callTool('toolName', { arg: 'value' });
await client.listResources();
await client.readResource('uri://resource');
await client.listPrompts();
await client.getPrompt('promptName', { arg: 'value' });
await client.close();
```

### InMemoryTransport

```typescript
const { clientTransport, serverTransport } = InMemoryTransport.createPair();
```

## Documentation

**[Read the full documentation](https://v-checha.github.io/mcpkit/)**

- [Testing Guide](https://v-checha.github.io/mcpkit/docs/guides/testing)

## Related Packages

- [@mcpkit-dev/core](https://www.npmjs.com/package/@mcpkit-dev/core) - Core framework
- [@mcpkit-dev/cli](https://www.npmjs.com/package/@mcpkit-dev/cli) - CLI tool

## License

MIT
npm package: @mcpkit/server-sdk
Description: SDK for interacting with the MCP Kit Server
Author: Trevor Uptain
Latest version: 0.1.2

# MCP Kit Server SDK

## Purpose

This TypeScript SDK provides a client interface for interacting with the MCP Kit API.

## Installation

```bash
npm install @mcpkit/server-sdk
# or yarn add @mcpkit/server-sdk
# or pnpm add @mcpkit/server-sdk
```

## Usage (`McpServerClient`)

```typescript
import { McpServerClient } from "@mcpkit/server-sdk";

const apiKey = process.env.MCPKIT_API_KEY; // Ensure this is set
if (!apiKey) {
  throw new Error("MCPKIT_API_KEY environment variable is not set.");
}

const client = new McpServerClient(apiKey);

async function listServers() {
  try {
    const servers = await client.getServers();
    console.log("Available Servers:", servers);

    if (servers.length > 0) {
      const firstServerId = servers[0].id;
      const tools = await client.getToolsForServer(firstServerId);
      console.log(`Tools for server ${firstServerId}:`, tools);
    }
  } catch (error) {
    console.error("Error interacting with MCP Kit Server:", error);
  }
}

listServers();
```

## Development

1.  **Install Dependencies**:
    ```bash
    npm install
    # or yarn install / pnpm install
    ```
2.  **Build**:
    ```bash
    npm run build # Or equivalent script (likely runs tsc)
    ```
    This compiles TypeScript files from `src/` to JavaScript in `dist/`.
npm package: @mcplex-js/webpack-plugin
Description: Webpack plugin for MCPlex that compiles tools, generates TypeScript declarations, and creates WASM files
Author: MCPlex
Latest version: 0.1.0

# @mcplex-js/webpack-plugin

A Webpack plugin for MCPlex that automates the compilation of tools, generates TypeScript declarations, and creates WASM files.

## Features

- **AST-based Function Extraction**: Uses TypeScript's compiler API to accurately parse and extract exported functions
- **Tools Compilation**: Compiles `tools.ts` to clean `tools.js` output using webpack
- **TypeScript Declarations**: Generates `tools.d.ts` with proper type definitions (`I32` return types, no parameters)
- **WASM Generation**: Converts compiled tools to WASM using `extism-js`
- **Asset Management**: Copies `mcplex.json` to the output directory
- **Dual Format Support**: Available in both ESM and CommonJS formats

## Installation

```bash
npm install @mcplex-js/webpack-plugin
```

## Usage

### Basic Usage

```javascript
const MCPlexWebpackPlugin = require('@mcplex-js/webpack-plugin');

module.exports = {
  // ... your webpack config
  plugins: [
    new MCPlexWebpackPlugin({
      inputFile: 'src/tools.ts',
      moduleName: 'main',
    })
  ]
};
```

### ES Modules

```javascript
import MCPlexWebpackPlugin from '@mcplex-js/webpack-plugin';

export default {
  // ... your webpack config
  plugins: [
    new MCPlexWebpackPlugin({
      inputFile: 'src/tools.ts',
      moduleName: 'main',
    })
  ]
};
```

## Configuration Options

| Option | Type | Default | Description |
|--------|------|---------|-------------|
| `inputFile` | `string` | `'src/tools.ts'` | Path to the tools TypeScript file |
| `moduleName` | `string` | `'main'` | Module name for the generated declarations |
| `compileTools` | `boolean` | `true` | Enable tools compilation |
| `copyMcplexJson` | `boolean` | `true` | Copy mcplex.json to output directory |
| `generateWasm` | `boolean` | `true` | Generate WASM file using extism-js |
| `mcplexJsonPath` | `string` | `'mcplex.json'` | Path to mcplex.json file |

## Example Configuration

```javascript
const MCPlexWebpackPlugin = require('@mcplex-js/webpack-plugin');

module.exports = {
  entry: './src/index.ts',
  output: {
    path: path.resolve(__dirname, 'dist'),
    filename: 'bundle.js',
  },
  plugins: [
    new MCPlexWebpackPlugin({
      inputFile: 'src/tools.ts',
      moduleName: 'main',
      compileTools: true,
      copyMcplexJson: true,
      generateWasm: true,
      mcplexJsonPath: 'mcplex.json',
    })
  ]
};
```

## Output Files

The plugin generates the following files in your webpack output directory:

- `tools.js` - Compiled tools (CommonJS format)
- `tools.d.ts` - TypeScript declarations with `I32` return types
- `tools.wasm` - WASM file generated from tools.js
- `mcplex.json` - Copied configuration file

## Requirements

- Node.js >= 16
- Webpack >= 5.0.0
- `extism-js` CLI tool (for WASM generation)

## License

MIT
npm package: @mcploom/codexec-protocol
Description: Transport-safe protocol and dispatcher helpers for mcploom codexec executors.
Latest version: 0.1.2

# @mcploom/codexec-protocol

Transport-safe messages and host-session helpers for transport-backed codexec runtimes.

[![npm version](https://img.shields.io/npm/v/%40mcploom%2Fcodexec--protocol?style=flat-square)](https://www.npmjs.com/package/@mcploom/codexec-protocol)
[![License](https://img.shields.io/github/license/aallam/mcploom?style=flat-square)](https://github.com/aallam/mcploom/blob/main/LICENSE)

## What This Package Is For

This is a low-level package for building transport-backed codexec runtimes. It does not execute guest code by itself.

It currently provides:

- runner/dispatcher message types
- a shared host transport session for worker/process-style executors
- the same host transport session shape used by `@mcploom/codexec-remote`
- transport-facing access to the shared manifest and dispatcher model from `@mcploom/codexec`

Most application code should use `@mcploom/codexec` plus an executor package directly instead of importing this package.
Treat this package as experimental and transport-internal while the execution architecture is still evolving.

## Used By

- `@mcploom/codexec-worker`
- `@mcploom/codexec-process`
- `@mcploom/codexec-remote`

`@mcploom/codexec-quickjs` and `@mcploom/codexec-isolated-vm` use the shared runner semantics from `@mcploom/codexec` directly and do not currently depend on this package.

## Install

```bash
npm install @mcploom/codexec @mcploom/codexec-protocol
```

## Security Notes

- This package is protocol glue, not a sandbox.
- It does not provide isolation by itself.
- The host tool surface remains the real capability boundary.
- Worker/process lifecycle isolation comes from the surrounding executor package, not from this package alone.

## Architecture Docs

- [Codexec architecture overview](https://github.com/aallam/mcploom/blob/main/docs/codexec/architecture/README.md)
- [Codexec MCP adapters and protocol](https://github.com/aallam/mcploom/blob/main/docs/codexec/architecture/codexec-mcp-and-protocol.md)
npm package: @mcploom/codexec-quickjs
Description: QuickJS executor for the mcploom codexec core package.
Latest version: 0.2.1

# @mcploom/codexec-quickjs

QuickJS executor backend for `@mcploom/codexec`.

[![npm version](https://img.shields.io/npm/v/%40mcploom%2Fcodexec--quickjs?style=flat-square)](https://www.npmjs.com/package/@mcploom/codexec-quickjs)
[![License](https://img.shields.io/github/license/aallam/mcploom?style=flat-square)](https://github.com/aallam/mcploom/blob/main/LICENSE)

## Choose QuickJS When

- you want the easiest codexec backend to install
- you do not want a native addon in CI or local development
- you want fresh runtimes, captured `console.*` output, and JSON-only tool boundaries

## Security Notes

- Each execution gets a fresh QuickJS runtime with no ambient Node globals injected by codexec.
- Tool calls cross a JSON-only bridge, and executor timeouts propagate abort signals to in-flight provider work.
- In the default deployment model, provider definitions are controlled by the host application, while hostile users control guest code and tool inputs.
- This package is not presented as a hard security boundary for hostile code. It is best-effort in-process isolation.
- If you need a stronger boundary, run codexec behind a separate process or container.

## Architecture Docs

- [Codexec architecture overview](https://github.com/aallam/mcploom/blob/main/docs/codexec/architecture/README.md)
- [Codexec executors](https://github.com/aallam/mcploom/blob/main/docs/codexec/architecture/codexec-executors.md)
- [Codexec MCP adapters and protocol](https://github.com/aallam/mcploom/blob/main/docs/codexec/architecture/codexec-mcp-and-protocol.md)

## Examples

- [Basic provider execution](https://github.com/aallam/mcploom/blob/main/examples/codexec-basic.ts)
- [Worker-backed QuickJS execution](https://github.com/aallam/mcploom/blob/main/examples/codexec-worker.ts)
- [MCP provider wrapping](https://github.com/aallam/mcploom/blob/main/examples/codexec-mcp-provider.ts)
- [MCP server wrapper](https://github.com/aallam/mcploom/blob/main/examples/codexec-mcp-server.ts)
- [Full examples index](https://github.com/aallam/mcploom/tree/main/examples)

## Install

```bash
npm install @mcploom/codexec @mcploom/codexec-quickjs
```

Advanced consumers can also import the reusable QuickJS runner from `@mcploom/codexec-quickjs/runner`.
Transport-backed executors such as `@mcploom/codexec-worker` and `@mcploom/codexec-process` also reuse the shared QuickJS protocol endpoint from `@mcploom/codexec-quickjs/runner/protocol-endpoint`.

## Usage

```ts
import { resolveProvider } from "@mcploom/codexec";
import { QuickJsExecutor } from "@mcploom/codexec-quickjs";

const provider = resolveProvider({
  tools: {
    echo: {
      execute: async (input) => input,
    },
  },
});

const executor = new QuickJsExecutor();
const result = await executor.execute("await codemode.echo({ ok: true })", [
  provider,
]);
```

Each execution runs in a fresh QuickJS runtime with timeout handling, captured logs, and JSON-only result and tool boundaries.
npm package: @mcplug/vite
Description: Vite plugin to develop mcplug MCP servers
Author: beynar
Latest version: 1.0.15

# mcplug-vite-plugin

A Vite plugin for seamlessly integrating MCP (Model Context Protocol) servers with Cloudflare Workers.

## Features

- **One-Click Deployment**: Automatically configures and deploys your MCP servers to Cloudflare Workers
- **Streamlined Development**: Integrated development environment with hot reloading
- **Configuration Management**: Handles environment variables and configuration between local and deployed environments
- **Zero-Config Setup**: Works out of the box with sensible defaults

## Installation

```bash
npm install @mcplug/vite-plugin
```

## Usage

Add the plugin to your `vite.config.ts`:

```ts
import { defineConfig } from "vite";
import { mcplug } from "@mcplug/vite-plugin";

export default defineConfig({
  plugins: mcplug();
});
```

## How It Works

The plugin:

1. Creates necessary directories and configuration files
2. Generates a Cloudflare Worker from your MCP server
3. Configures Wrangler for deployment
4. Integrates with your development workflow

## Requirements

- Node.js 16+
- Vite 4+
- Cloudflare account (for deployments)

## About mcplug

mcplug is a marketplace for MCP servers, providing a unified endpoint for integrating APIs and external tools into AI applications. Learn more at [mcplug.io](https://mcplug.io).

## License

MIT
npm package: @mcpmesh/cli
Description: CLI for MCP Mesh — build distributed AI agents with auto-discovery, dependency injection, and LLM integration
Author: MCP Mesh Contributors
Latest version: 1.2.0

# @mcpmesh/cli

CLI for **MCP Mesh** - Distributed Service Mesh for AI Agents.

## Installation

```bash
npm install -g @mcpmesh/cli
```

This installs two binaries:

- **meshctl** - CLI tool for managing MCP Mesh agents and tools
- **mcp-mesh-registry** - Registry service for service discovery

> **Note:** This package supports Linux and macOS only. For Windows, use WSL2 or Docker.

## Quick Start

```bash
# Show help and available commands
meshctl --help

# Comprehensive documentation (great for LLMs!)
meshctl man

# Scaffold a new agent project
meshctl scaffold my-agent --dry-run

# List running agents
meshctl list

# List all tools across agents
meshctl list --tools

# Call an MCP tool
meshctl call get_current_time

# Start the registry service (Linux/macOS)
mcp-mesh-registry --help
```

## What is MCP Mesh?

MCP Mesh is a distributed service mesh built on the Model Context Protocol (MCP). It enables:

- **AI Agent Orchestration** - Connect and coordinate multiple AI agents
- **Service Discovery** - Automatic registration and capability-based routing
- **Dependency Injection** - Automatic resolution of agent dependencies
- **Multi-Environment** - Local development, Docker, Kubernetes support
- **Production Ready** - Health monitoring, graceful degradation, resilience patterns

## Key Commands

| Command                   | Description                 |
| ------------------------- | --------------------------- |
| `meshctl man`             | Comprehensive documentation |
| `meshctl scaffold <name>` | Generate new agent project  |
| `meshctl list`            | List running agents         |
| `meshctl list --tools`    | List all tools              |
| `meshctl call <tool>`     | Invoke an MCP tool          |
| `meshctl registry`        | Manage the registry         |

## For LLMs

This package is designed to be easily discoverable by LLMs. After installation:

```bash
# Get full documentation
meshctl man

# Discover available tools
meshctl list --tools

# Get tool details with input schema
meshctl list --tools=<tool_name>
```

## Links

- [Documentation](https://mcp-mesh.ai/)
- [GitHub Repository](https://github.com/dhyansraj/mcp-mesh)
- [PyPI Package](https://pypi.org/project/mcp-mesh/)
- [Docker Images](https://hub.docker.com/u/mcpmesh)

## License

MIT
npm package: @mcprelay/client
Description: MCP client for MCPRelay proxy service - provides web access for AI agents
Author: MCPRelay
Latest version: 1.0.7

# MCPRelay Client

MCP client for MCPRelay proxy service - provides secure web access for AI agents like Claude.

## Installation

```bash
npm install -g @mcprelay/client
```

## Quick Setup

1. **Install the client globally:**
   ```bash
   npm install -g @mcprelay/client
   ```

2. **Configure Claude Desktop:**
   
   Add this to your Claude Desktop config file:
   
   **macOS:** `~/Library/Application Support/Claude/claude_desktop_config.json`
   **Windows:** `%APPDATA%\Claude\claude_desktop_config.json`
   **Linux:** `~/.config/Claude/claude_desktop_config.json`

   ```json
   {
     "mcpServers": {
       "mcprelay": {
         "command": "mcprelay-client",
         "env": {
           "PROXY_API_URL": "https://api.mcprelay.dev"
         }
       }
     }
   }
   ```

3. **Restart Claude Desktop and start using!**

## Available Tools

### `fetch_with_proxy`
Fetches URLs using smart proxy selection:
```
Use fetch_with_proxy to get content from https://example.com
```

### `get_proxy_stats` 
View your usage statistics:
```
Show my proxy usage stats for the last 7 days
```

### `get_balance`
Check your current credit balance:
```
What's my current MCPRelay balance?
```

## Features

✅ **Secure** - Your API keys never leave MCPRelay's servers  
✅ **Simple** - No API key management needed  
✅ **Fast** - MCP runs locally, minimal latency  
✅ **Smart** - Automatic proxy selection based on site requirements  
✅ **Transparent** - Clear usage tracking and costs  

## How It Works

```
Claude Desktop → MCPRelay Client → MCPRelay API → Web Content
```

The client runs locally and securely proxies requests through MCPRelay's infrastructure.

## Support

- **Website:** https://mcprelay.dev
- **Issues:** https://github.com/yourusername/mcp-proxy-service/issues
- **Docs:** https://mcprelay.dev/docs

## License

MIT
npm package: @mcpronovost/qpfilters
Description: An easy-to-use collection of filters, mostly created to be used with Vue.js.
Author: M-C Pronovost
Latest version: 2.2.0

# qp-filters &middot; [![npm version](https://img.shields.io/npm/v/@mcpronovost/qpfilters.svg?style=flat)](https://www.npmjs.com/package/@mcpronovost/qpfilters) [![npm license](https://img.shields.io/npm/l/@mcpronovost/qpfilters?color=%231081c2)](https://github.com/mcpronovost/qp-filters/blob/main/LICENSE)

An easy-to-use collection of filters, originally created for use in a roleplaying project build with Vue.js 3.

## Install

```
  $ npm install @mcpronovost/qpfilters --save
```

## Available Filters

* [qpabbr](https://github.com/mcpronovost/qp-filters/wiki/qpabbr)
* [qpcode](https://github.com/mcpronovost/qp-filters/wiki/qpcode)
* [qpdate](https://github.com/mcpronovost/qp-filters/wiki/qpdate)
* [qprhex](https://github.com/mcpronovost/qp-filters/wiki/qprhex)
* [qpslug](https://github.com/mcpronovost/qp-filters/wiki/qpslug)
* [qpunit](https://github.com/mcpronovost/qp-filters/wiki/qpunit)

## Usage

### Direct include (Vue.js 3)

``` vue
<script setup>
  import { qpdate } from "@mcpronovost/qpfilters";
  // ...
</script>

<template>
  <span v-text="qpdate(props.topic.created_at)"></span>
</template>
```

### Global include (Vue.js 3)

``` javascript
    import { createApp } from "vue";
    import qpfilters from "@mcpronovost/qpfilters";

    const app = createApp(App);

    app.config.globalProperties.$f = qpfilters;
```

``` vue
    <script setup>
        // ...
    </script>

    <template>
        <span v-text="$f.qpdate(props.topic.created_at)"></span>
    </template>
```

--------------------------------------------------------------------

## Examples

### qpabbr

``` javascript
qpabbr("Pachu'a Wapi Qatlaalawsiq")
```

`PWQ`

### qpcode

``` javascript
qpcode("This is a [g]bold text[/g] and \n this is an [i]italic text[/i].")
```

`This is a <span style="font-weight:bold;">bold text</span> and <br /> this is an <span style="font-style:italic;">italic text</span>.`

### qpdate

``` javascript
qpdate("2022-10-31T13:50:14.836475-04:00")
```

`31 octobre 2022 à 13:50`

### qprhex

``` javascript
qprhex()
```

`#89a411`

### qpslug

``` javascript
qpslug("Au royaume empoisonné feat. Seðem")
```

`au-royaume-empoisonne-feat-sedem`

### qpunit

``` javascript
qpunit(4928)
```

`4.93k`

--------------------------------------------------------------------

## History

* See [qp-filters release](https://github.com/mcpronovost/qp-filters/releases) list.

## License

This project is licensed under the MIT License - see the [LICENSE](https://github.com/mcpronovost/qp-filters/blob/main/LICENSE) file for details.
npm package: @mcpsearch/cli
Description: MCPSearch CLI - Discover and install MCP servers for Claude Code, Cursor, Windsurf, and more
Author: MCPSearch
Latest version: 0.1.0

# @mcpsearch/cli

The official CLI for [MCPSearch](https://mcpsearch.com) - discover and install MCP (Model Context Protocol) servers for your AI coding tools.

## Installation

```bash
npm install -g @mcpsearch/cli
```

Or use with npx (no install required):

```bash
npx @mcpsearch/cli search filesystem
```

## Supported Tools

- **Claude Code** - Anthropic's AI coding assistant
- **Cursor** - AI-powered code editor
- **Windsurf** - Codeium's AI IDE
- **Continue.dev** - Open-source AI code assistant

## Commands

### Search for packages

```bash
mcp search <query>

# Examples
mcp search filesystem
mcp search database --category database
mcp search api --limit 5
```

### Install a package

```bash
mcp install <package>

# Auto-detect your AI tool and install
mcp install @modelcontextprotocol/server-filesystem

# Install for a specific tool
mcp install mongodb-mcp-server --tool cursor

# Install multiple packages
mcp install @anthropic/mcp-server-fetch @anthropic/mcp-server-brave-search
```

### List installed packages

```bash
mcp list

# List for specific tool
mcp list --tool claudeCode

# Output as JSON
mcp list --json
```

### Show package info

```bash
mcp info <package>

# Example
mcp info @modelcontextprotocol/server-filesystem
```

### Remove a package

```bash
mcp remove <package>

# Example
mcp remove @modelcontextprotocol/server-filesystem --tool claudeCode
```

## Configuration

The CLI stores configuration in `~/.config/mcpsearch/config.json`.

### Set default tool

```bash
mcp config set defaultTool claudeCode
```

### Set custom registry URL

```bash
mcp config set registry https://api.mcpsearch.com
```

## How It Works

When you run `mcp install <package>`, the CLI:

1. Looks up the package in the MCPSearch registry
2. Detects which AI tool(s) you have installed
3. Adds the MCP server configuration to your tool's config file:
   - Claude Code: `~/.claude/settings.json`
   - Cursor: `~/.cursor/mcp.json`
   - Windsurf: `~/.windsurf/mcp.json`
   - Continue.dev: `~/.continue/config.json`
4. The server runs via `npx` when your AI tool starts

## Environment Variables

- `MCP_REGISTRY_URL` - Override the default registry URL

## Links

- [MCPSearch Website](https://mcpsearch.com)
- [Documentation](https://mcpsearch.com/docs)
- [Browse Packages](https://mcpsearch.com/search)
- [MCP Specification](https://modelcontextprotocol.io)

## License

MIT