open-index/open-npm huggingface dataset:
npm package: @mcp-extras/loopback
Description: A loopback transport that allows in memory communication between model context protocol clients and servers
Latest version: 0.0.9

# @mcpextras/loopback

A simple, efficient **in-memory Loopback Transport** implementation for the **Model Context Protocol (MCP)**,
enabling MCP client-server interactions within the same execution context.

# External Links
* [Github](https://github.com/phil-rice/mcp-extras)
* [npmjs](https://www.npmjs.com/package/@mcp-extras/loopback)
* [Discussion in modelcontextprotocol](https://github.com/orgs/modelcontextprotocol/discussions/313)

---

## Overview

The **Loopback Transport** simplifies development and testing of MCP-based applications by providing an in-memory communication channel.
It's ideal for browser-based applications, integration tests, rapid prototyping, and scenarios where external network transports
(such as SSE or HTTP) add unnecessary complexity or overhead.

This transport is fully compatible with the [Model Context Protocol (MCP)](https://modelcontextprotocol.io)
and can be seamlessly integrated into existing MCP-based projects.

---

## Installation

Install via npm or yarn. One of the following commands will work:

```bash
npm install @mcp-extras/loopback
yarn add @mcp-extras/loopback
```

## Usage

```typescript
import {Client} from "@modelcontextprotocol/sdk/client/index.js";
import {Server} from "@modelcontextprotocol/sdk/server/index.js";
import {LoopbackTransport} from "@mcp-extras/loopback";

// Create server and client
const server = new McpServer({ name: "example-server", version: "1.0.0" });
const client = new Client({ name: "example-client", version: "1.0.0" });

// Create loopback transports
const clientTransport = new LoopbackTransport({ name: "client" });
const serverTransport = new LoopbackTransport({ name: "server" });

// Connect transports in-memory
clientTransport.connect(serverTransport);

// Connect to MCP
await server.connect(serverTransport);
await client.connect(clientTransport);
```

# Configuration

```typescript
export type ClientOrServer = 'client' | 'server' | 'unknown';
export type LoopbackTransportConfig = {
    /** If you give this debugging is easier, and it is included in the debug log. Should be client or server */
    name?: ClientOrServer
    /** If true then debug messages will appear in the console */
    debug?: boolean
    /** If true then messages are 'serialised/deserialised'. This means the server gets a totally different copy. While this slows things down it more closely duplicates the behavior of the other transports*/
    stringifyMessage?: boolean
}
//...
//examples:
const transport = new LoopbackTransport(); //Although this works, it's great when developing/debugging to have a name which is 'client' or 'server'
const clientTransport = new LoopbackTransport({name: "client", stringifyMessage: true});
const serverTransport = new LoopbackTransport({name: "server", debug: true});

```
npm package: @mcp-forge/listmonk-mcp
Description: MCP server wrapper for ListMonk API using Stainless-generated SDK
Author: MCP Forge
Latest version: 1.1.1

# ListMonk MCP Server

This is an MCP (Model Context Protocol) server that wraps the ListMonk API using the Stainless-generated TypeScript SDK.

## Installation

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

## Configuration

Set the following environment variables:

```bash
# ListMonk API Configuration
export LISTMONK_BASE_URL="http://localhost:9000/api"  # Your ListMonk instance
export LISTMONK_USERNAME="admin"                      # Admin username
export LISTMONK_PASSWORD="your-password"              # Admin password
# OR
export LISTMONK_API_KEY="your-api-key"               # If using API key auth
```

Alternatively, you can use the SDK's default environment variable names:
- `LISTMONK_PATIENT_HJ6V_BASE_URL`
- `LISTMONK_PATIENT_HJ6V_USERNAME`
- `LISTMONK_PATIENT_HJ6V_PASSWORD`
- `LISTMONK_PATIENT_HJ6V_API_KEY`

## Usage

### Running the Server

```bash
npm start
```

### Available Tools

#### Lists Management
- `listmonk_list_lists` - Get all lists
- `listmonk_create_list` - Create a new list
- `listmonk_get_list` - Get a specific list
- `listmonk_update_list` - Update a list

#### Subscribers Management
- `listmonk_list_subscribers` - Get all subscribers
- `listmonk_create_subscriber` - Create a new subscriber
- `listmonk_get_subscriber` - Get a specific subscriber
- `listmonk_update_subscriber` - Update a subscriber
- `listmonk_bulk_update_lists` - Bulk update subscriber list memberships

#### Campaigns Management
- `listmonk_list_campaigns` - Get all campaigns
- `listmonk_create_campaign` - Create a new campaign
- `listmonk_get_campaign` - Get a specific campaign
- `listmonk_update_campaign_status` - Update campaign status
- `listmonk_send_test_campaign` - Send test campaign email

#### Templates Management
- `listmonk_list_templates` - Get all templates
- `listmonk_create_template` - Create a new template

#### Import Management
- `listmonk_import_subscribers` - Import subscribers from CSV

#### Media Management
- `listmonk_list_media` - Get all media files
- `listmonk_upload_media` - Upload a media file

#### Settings Management
- `listmonk_update_settings` - Update ListMonk settings

#### Health Check
- `listmonk_health_check` - Check API health status

### Integration with Claude Desktop

Add to your Claude Desktop configuration:

```json
{
  "mcpServers": {
    "listmonk": {
      "command": "node",
      "args": ["/path/to/listmonk-mcp-wrapper/dist/index.js"],
      "env": {
        "LISTMONK_BASE_URL": "http://localhost:9000/api",
        "LISTMONK_USERNAME": "admin",
        "LISTMONK_PASSWORD": "your-password"
      }
    }
  }
}
```

## Development

```bash
# Run in development mode
npm run dev

# Build for production
npm run build
```

## Note

This MCP server uses the Stainless-generated SDK which was created with the name "listmonk-patient-hj6v" but contains the complete ListMonk API implementation.
npm package: @mcp-forge/mautic-mcp
Description: MCP server wrapper for Mautic API using Stainless-generated SDK
Author: MCP Forge
Latest version: 1.1.1

# Mautic MCP Server

This is an MCP (Model Context Protocol) server that wraps the Mautic API using the Stainless-generated TypeScript SDK.

## Installation

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

## Configuration

Set the following environment variables:

```bash
# Mautic API Configuration
export MAUTIC_BASE_URL="https://your-mautic-instance.com/api"
export MAUTIC_USERNAME="your-username"     # For Basic Auth
export MAUTIC_PASSWORD="your-password"     # For Basic Auth
# OR
export MAUTIC_API_KEY="your-api-key"       # For API Key auth
```

Alternatively, you can use the SDK's default environment variable names:
- `LISTMONK_PATIENT_CTHR_BASE_URL`
- `LISTMONK_PATIENT_CTHR_USERNAME`
- `LISTMONK_PATIENT_CTHR_PASSWORD`
- `LISTMONK_PATIENT_CTHR_API_KEY`

## Usage

### Running the Server

```bash
npm start
```

### Available Tools

#### Lists (Segments) Management
- `mautic_list_lists` - Get all Mautic lists/segments
- `mautic_create_list` - Create a new list/segment
- `mautic_get_list` - Get a specific list/segment

#### Contacts Management
- `mautic_list_contacts` - Get all contacts
- `mautic_create_contact` - Create a new contact
- `mautic_get_contact` - Get a specific contact
- `mautic_update_contact` - Update a contact

#### Campaigns Management
- `mautic_list_campaigns` - Get all campaigns
- `mautic_create_campaign` - Create a new campaign
- `mautic_get_campaign` - Get a specific campaign
- `mautic_update_campaign_status` - Update campaign status

#### Templates Management
- `mautic_list_templates` - Get all email templates
- `mautic_create_template` - Create a new email template

#### Media Management
- `mautic_list_media` - Get all media files
- `mautic_upload_media` - Upload a media file

#### Settings Management
- `mautic_update_settings` - Update Mautic settings

#### Health Check
- `mautic_health_check` - Check API health status

### Integration with Claude Desktop

Add to your Claude Desktop configuration:

```json
{
  "mcpServers": {
    "mautic": {
      "command": "node",
      "args": ["/path/to/mautic-mcp-wrapper/dist/index.js"],
      "env": {
        "MAUTIC_BASE_URL": "https://your-mautic-instance.com/api",
        "MAUTIC_USERNAME": "your-username",
        "MAUTIC_PASSWORD": "your-password"
      }
    }
  }
}
```

## Development

```bash
# Run in development mode
npm run dev

# Build for production
npm run build
```

## Note

This MCP server uses the Stainless-generated SDK which was created with the name "listmonk-patient-cthr" but actually contains the Mautic API implementation.
npm package: @mcp-funnel/schemas
Description: Zod schemas for validating `.mcp-funnel.json` configuration files.
Author: Christoph Schramm
Latest version: 0.0.8

# @mcp-funnel/schemas

Zod schemas for validating `.mcp-funnel.json` configuration files.

## Responsibility

Exports validation for MCP Funnel configuration structure and provides TypeScript types via Zod schema inference.

## Installation

```bash
yarn add @mcp-funnel/schemas
```

## Core Exports

- **ProxyConfigSchema** - Validates root `.mcp-funnel.json` structure
- **TargetServerSchema** - Validates individual server configurations
- **ProxyConfig** type - Inferred TypeScript type for config
- **TargetServer** type - Inferred TypeScript type for server

## Usage

```typescript
import { ProxyConfigSchema, type ProxyConfig } from '@mcp-funnel/schemas';

const result = ProxyConfigSchema.safeParse(rawConfig);
if (result.success) {
  const config: ProxyConfig = result.data;
  // Type-safe configuration access
}
```

## Schema Coverage

- Server configurations (stdio, SSE, WebSocket, HTTP transports)
- Authentication (bearer, OAuth2 flows)
- Secret providers (dotenv, process, inline)
- Tool filtering (expose/hide patterns)
- Auto-reconnection settings
- Command configurations

## For Developers

Internal infrastructure package used by `@mcp-funnel/server` for config validation at startup. Depends on `@mcp-funnel/auth` for OAuth2 schemas.

## License

MIT
npm package: @mcp-get-community/server-curl
Description: MCP server for making HTTP requests using a curl-like interface
Author: Michael Latman
Latest version: 0.1.0

# @mcp-get-community/server-curl

An MCP server that allows LLMs to make HTTP requests to any URL using a curl-like interface.

## Features

- Make HTTP requests to any URL
- Support for all common HTTP methods (GET, POST, PUT, DELETE, PATCH, HEAD, OPTIONS)
- Customizable headers and request body
- Configurable timeout
- Full response information including status, headers, and body

## Installation

```bash
npx @michaellatman/mcp-get@latest install @mcp-get-community/server-curl
```

## Usage

```json
{
  "mcpServers": {
    "@mcp-get-community/server-curl": {
      "runtime": "node",
      "command": "npx",
      "args": [
        "-y",
        "@mcp-get-community/server-curl"
      ]
    }
  }
}
```

The server provides a single tool called `curl` that accepts the following parameters:

- `url` (required): The URL to make the request to
- `method` (optional): HTTP method to use (default: 'GET')
- `headers` (optional): Object containing HTTP headers
- `body` (optional): Request body for POST/PUT/PATCH requests
- `timeout` (optional): Request timeout in milliseconds (default: 30000, max: 300000)

### Example Request

```json
{
  "url": "https://api.example.com/data",
  "method": "POST",
  "headers": {
    "Content-Type": "application/json",
    "Authorization": "Bearer token123"
  },
  "body": "{\"key\": \"value\"}",
  "timeout": 5000
}
```

### Example Response

```json
{
  "status": 200,
  "statusText": "OK",
  "headers": {
    "content-type": "application/json",
    "server": "nginx"
  },
  "body": "{\"result\": \"success\"}"
}
```

## Development

```bash
# Install dependencies
npm install

# Build the project
npm run build

# Run in development mode
npm run dev
```

## License

MIT
npm package: @mcp-get-community/server-macos
Description: MCP server for macOS system operations
Author: Michael Latman
Latest version: 0.1.0

# @mcp-get-community/server-macos

A Model Context Protocol server that provides macOS-specific system information and operations.

## Features

- System information retrieval (CPU, Memory, Disk, Network)
- Native macOS notifications

## Installation

```bash
npx @michaellatman/mcp-get@latest install @mcp-get-community/server-macos
```

## Configuration

Add this to your configuration:

```json
{
  "mcpServers": {
    "@mcp-get-community/server-macos": {
      "runtime": "node",
      "command": "npx",
      "args": [
        "-y",
        "@mcp-get-community/server-macos"
      ]
    }
  }
}
```

## Tools

### systemInfo

Retrieves system information from macOS.

Parameters:
- `category` (required): One of 'cpu', 'memory', 'disk', 'network', or 'all'

Example:
```json
{
  "name": "systemInfo",
  "arguments": {
    "category": "cpu"
  }
}
```

### sendNotification

Sends a native macOS notification.

Parameters:
- `title` (required): Title of the notification
- `message` (required): Content of the notification
- `sound` (optional): Whether to play a sound (default: true)

Example:
```json
{
  "name": "sendNotification",
  "arguments": {
    "title": "Hello",
    "message": "This is a test notification",
    "sound": true
  }
}
```

## Development

1. Install dependencies:
```bash
npm install
```

2. Build the project:
```bash
npm run build
```

3. Run in development mode:
```bash
npm run dev
```

## License

MIT