open-index/open-npm huggingface dataset:
npm package: @mseep/mcp-pg-schema
Description: MCP server for getting schema information from a PostgreSQL database
Author: Vince Coppola
Latest version: 0.0.1

# PostgreSQL

A Model Context Protocol server that provides read-only access to PostgreSQL databases. This server enables LLMs to inspect database schemas and execute read-only queries.

## Components

### Tools

- **query**
  - Execute read-only SQL queries against the connected database
  - Input: `sql` (string): The SQL query to execute
  - All queries are executed within a READ ONLY transaction

### Resources

The server provides schema information for each table in the database:

- **Table Schemas** (`postgres://<host>/<table>/schema`)
  - JSON schema information for each table
  - Includes column names and data types
  - Automatically discovered from database metadata

## Usage with Claude Desktop

To use this server with the Claude Desktop app, add the following configuration to the "mcpServers" section of your `claude_desktop_config.json`:

### Docker

* when running docker on macos, use host.docker.internal if the server is running on the host network (eg localhost)
* username/password can be added to the postgresql url with `postgresql://user:password@host:port/db-name`

```json
{
  "mcpServers": {
    "postgres": {
      "command": "docker",
      "args": [
        "run", 
        "-i", 
        "--rm", 
        "mcp/postgres", 
        "postgresql://host.docker.internal:5432/mydb"]
    }
  }
}
```

### NPX

```json
{
  "mcpServers": {
    "postgres": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-postgres",
        "postgresql://localhost/mydb"
      ]
    }
  }
}
```

Replace `/mydb` with your database name.

## Building

Docker:

```sh
docker build -t mcp/postgres -f src/postgres/Dockerfile . 
```

## License

This MCP server is licensed under the MIT License. This means you are free to use, modify, and distribute the software, subject to the terms and conditions of the MIT License. For more details, please see the LICENSE file in the project repository.
npm package: @mseep/mcp-playwright-cdp
Description: Model Context Protocol server for Playwright with Chrome DevTools Protocol support
Author: Lars Hagen
Latest version: 0.2.10

# MCP Playwright CDP
[![smithery badge](https://smithery.ai/badge/@lars-hagen/mcp-playwright-cdp)](https://smithery.ai/server/@lars-hagen/mcp-playwright-cdp)

[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://github.com/lars-hagen/mcp-playwright-cdp/blob/main/LICENSE)

A Model Context Protocol server that provides browser automation capabilities using Playwright with Chrome DevTools Protocol (CDP) support. This server enables LLMs to interact with web pages, take screenshots, and execute JavaScript in a real browser environment, with the ability to connect to existing Chrome instances via CDP.

> This is a fork of [executeautomation/mcp-playwright](https://github.com/executeautomation/mcp-playwright) v0.2.7, enhanced with CDP support for connecting to running Chrome instances.

<a href="https://glama.ai/mcp/servers/fdvu5n58kv"><img width="380" height="200" src="https://glama.ai/mcp/servers/fdvu5n58kv/badge" alt="Playwright CDP MCP server" /></a>

## Key Features

- 🔗 Connect to existing Chrome instances via CDP
- 🌐 Full browser automation capabilities
- 📸 Screenshot capture of entire pages or specific elements
- 🖱️ Comprehensive web interactions (navigation, clicking, form filling)
- 📊 Console log monitoring
- 🔧 JavaScript execution in browser context
- 🌍 HTTP API testing support

## Installation

You can install the package using either npm or Smithery:

### Installing via Smithery
To install MCP Playwright CDP for Claude Desktop automatically via [Smithery](https://smithery.ai/server/@lars-hagen/mcp-playwright-cdp):

```bash
npx -y @smithery/cli install @lars-hagen/mcp-playwright-cdp --client claude
```

### Manual Installation
Using npm:
```bash
npm install
```

## Configuration

Add this to your Claude Desktop configuration file:

```json
{
  "mcpServers": {
    "playwright": {
      "command": "node",
      "args": ["/path/to/mcp-playwright/dist/index.js"]
    }
  }
}
```
Replace `/path/to/mcp-playwright` with your actual path to the repository.

## CDP Connection

This fork adds the ability to connect to an existing Chrome instance via CDP. To use this feature:

1. Launch Chrome with remote debugging enabled:
```bash
/Applications/Google\ Chrome.app/Contents/MacOS/Google\ Chrome --remote-debugging-port=9222
```

2. The server will automatically attempt to connect to the running Chrome instance first, before launching a new browser.

## Credits

This project is a fork of [executeautomation/mcp-playwright](https://github.com/executeautomation/mcp-playwright), enhanced with CDP support for connecting to running Chrome instances.

## License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
npm package: @mseep/mcp-reasoner
Description: MCP Reasoner with multiple reasoning strategies including Beam Search and Monte Carlo Tree Search
Latest version: 2.0.0

# MCP Reasoner
A reasoning implementation for Claude Desktop that lets you use both Beam Search and Monte Carlo Tree Search (MCTS). tbh this started as a way to see if we could make Claude even better at complex problem-solving... turns out we definitely can.

### Current Version:
**v2.0.0**

#### What's New:

> Added 2 Experimental Reasoning Algorithms:
>
>     - `mcts-002-alpha`
>
>         - Uses the A* Search Method along with an early *alpha* implementation of a Policy Simulation Layer
>
>         - Also includes an early *alpha* implementation of Adaptive Exploration Simulator & Outcome Based Reasoning Simulator
>
>     *NOTE* the implementation of these alpha simulators is not complete and is subject to change
>
>     - `mcts-002alt-alpha`
>
>         - Uses the Bidirectional Search Method along with an early *alpha* implementation of a Policy Simulation Layer
>
>         - Also includes an early *alpha* implementation of Adaptive Exploration Simulator & Outcome Based Reasoning Simulator
>
>     *NOTE* the implementation of these alpha simulators is not complete and is subject to change


What happened to `mcts-001-alpha` and `mcts-001alt-alpha`?
> Quite simply: It was useless and near similar to the base `mcts` method. After initial testing the results yielded in basic thought processes was near similar showing that simply adding policy simulation may not have an effect.

So why add Polciy Simulation Layer now?
> Well i think its important to incorporate Policy AND Search in tandem as that is how most of the algorithms implement them.

#### Previous Versions:
**v1.1.0**

> Added model control over search parameters:
>
> beamWidth - lets Claude adjust how many paths to track (1-10)
>
> numSimulations - fine-tune MCTS simulation count (1-150)

## Features
- Two search strategies that you can switch between:
   - Beam search (good for straightforward stuff)
   - MCTS (when stuff gets complex) with alpha variations (see above)
- Tracks how good different reasoning paths are
- Maps out all the different ways Claude thinks through problems
- Analyzes how the reasoning process went
- Follows the MCP protocol (obviously)

## Installation
```
git clone https://github.com/frgmt0/mcp-reasoner.git 

OR clone the original:

git clone https://github.com/Jacck/mcp-reasoner.git

cd mcp-reasoner
npm install
npm run build
```

## Configuration
Add to Claude Desktop config:
```
{
  "mcpServers": {
    "mcp-reasoner": {
      "command": "node",
      "args": ["path/to/mcp-reasoner/dist/index.js"],
    }
  }
}
```

## Testing

[More Testing Coming Soon]

## Benchmarks

[Benchmarking will be added soon]

Key Benchmarks to test against:

- MATH500

- GPQA-Diamond

- GMSK8

- Maybe Polyglot &/or SWE-Bench

## License
This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
npm package: @mseep/mcp-ripgrep
Description: An MCP server to wrap ripgrep
Author: Matteo Collina
Latest version: 0.4.0

# MCP Ripgrep Server

An MCP server that provides ripgrep (rg) search capabilities to any MCP client such as Claude.

## Overview

This server provides a Model Context Protocol (MCP) interface for the powerful [ripgrep](https://github.com/BurntSushi/ripgrep) search tool. It enables Claude AI and other MCP-compatible clients to perform high-performance text searches across files on your system.

## Prerequisites

- Node.js (v18 or higher)
- ripgrep (`rg`) command installed and available in your PATH. Install it with `brew install ripgrep` on macOS.

## Usage with Claude for Desktop

To use this MCP server with Claude for Desktop:

1. Edit your Claude for Desktop configuration file:
   - macOS: `~/Library/Application Support/Claude/claude_desktop_config.json`
   - Windows: `%APPDATA%\Claude\claude_desktop_config.json`

2. Add the following to your configuration:
   ```json
   {
     "mcpServers": {
       "ripgrep": {
         "command": "npx",
         "args": ["-y", "mcp-ripgrep@latest"]
       }
     }
   }
   ```
   
   Replace `/path/to/mcp-ripgrep` with the absolute path to where you cloned this repository.

3. Restart Claude for Desktop.

## Available Tools

### search

Basic search with ripgrep:

```
Pattern: error
Path: ./src
```

### advanced-search

More advanced search with additional options:

```
Pattern: function
Path: ./src
FixedStrings: true
FileType: ts
IncludeHidden: false
```

### count-matches

Count occurrences of a pattern:

```
Pattern: TODO
Path: ./src
CountLines: true
```

### list-files

List files that would be searched without actually searching them:

```
Path: ./src
FileType: js
```

### list-file-types

List all supported file types in ripgrep.

## Security Considerations

This MCP server executes shell commands using the ripgrep tool. While efforts have been made to safely escape arguments, use caution when providing input as it runs commands on your machine.

## License

MIT
npm package: @mseep/mcp-screenshot
Description: A Model Context Protocol server that provides screenshot and OCR capabilities
Author: kazuph
Latest version: 1.0.4

# MCP Screenshot

An MCP server that captures screenshots and performs OCR text recognition.

<a href="https://glama.ai/mcp/servers/vcnmmaejv8"><img width="380" height="200" src="https://glama.ai/mcp/servers/vcnmmaejv8/badge" alt="mcp-screenshot MCP server" /></a>

## Features

- Screenshot capture (left half, right half, full screen)
- OCR text recognition (supports Japanese and English)
- Multiple output formats (JSON, Markdown, vertical, horizontal)

## OCR Engines

This server uses two OCR engines:

1. [yomitoku](https://github.com/kazuph/yomitoku)
   - Primary OCR engine
   - High-accuracy Japanese text recognition
   - Runs as an API server

2. [Tesseract.js](https://github.com/naptha/tesseract.js)
   - Fallback OCR engine
   - Used when yomitoku is unavailable
   - Supports both Japanese and English recognition

## Installation

```bash
npx -y @kazuph/mcp-screenshot
```

## Claude Desktop Configuration

Add the following configuration to your `claude_desktop_config.json`:

```json
{
  "mcpServers": {
    "screenshot": {
      "command": "npx",
      "args": ["-y", "@kazuph/mcp-screenshot"],
      "env": {
        "OCR_API_URL": "http://localhost:8000"  // yomitoku API base URL
      }
    }
  }
}
```

## Environment Variables

| Variable Name | Description | Default Value |
|--------------|-------------|---------------|
| OCR_API_URL | yomitoku API base URL | http://localhost:8000 |

## Usage Example

You can use it by instructing Claude like this:

```
Please take a screenshot of the left half of the screen and recognize the text in it.
```

## Tool Specification

### capture

Takes a screenshot and performs OCR.

Options:
- `region`: Screenshot area ('left'/'right'/'full', default: 'left')
- `format`: Output format ('json'/'markdown'/'vertical'/'horizontal', default: 'markdown')

## License

MIT

## Author

kazuph
npm package: @mseep/mcp-server
Description: MCP server for interacting with Make automations
Author: Make
Latest version: 0.5.0

# Make MCP Server (legacy)

**A modern, cloud-based version of the Make MCP Server is now available. For most use cases, we recommend using [this new version](https://developers.make.com/mcp-server).**

A Model Context Protocol server that enables Make scenarios to be utilized as tools by AI assistants. This integration allows AI systems to trigger and interact with your Make automation workflows.

## How It Works

The MCP server:

-   Connects to your Make account and identifies all scenarios configured with "On-Demand" scheduling
-   Parses and resolves input parameters for each scenario, providing AI assistants with meaningful parameter descriptions
-   Allows AI assistants to invoke scenarios with appropriate parameters
-   Returns scenario output as structured JSON, enabling AI assistants to properly interpret the results

## Benefits

-   Turn your Make scenarios into callable tools for AI assistants
-   Maintain complex automation logic in Make while exposing functionality to AI systems
-   Create bidirectional communication between your AI assistants and your existing automation workflows

## Usage with Claude Desktop

### Prerequisites

-   NodeJS
-   MCP Client (like Claude Desktop App)
-   Make API Key with `scenarios:read` and `scenarios:run` scopes

### Installation

To use this server with the Claude Desktop app, add the following configuration to the "mcpServers" section of your `claude_desktop_config.json`:

```json
{
    "mcpServers": {
        "make": {
            "command": "npx",
            "args": ["-y", "@makehq/mcp-server"],
            "env": {
                "MAKE_API_KEY": "<your-api-key>",
                "MAKE_ZONE": "<your-zone>",
                "MAKE_TEAM": "<your-team-id>"
            }
        }
    }
}
```

-   `MAKE_API_KEY` - You can generate an API key in your Make profile.
-   `MAKE_ZONE` - The zone your organization is hosted in (e.g., `eu2.make.com`).
-   `MAKE_TEAM` - You can find the ID in the URL of the Team page.
npm package: @mseep/mcp-server-airbnb
Description: MCP server for Airbnb search and listing details
Author: OpenBnB
Latest version: 0.1.0

# Airbnb MCP Server
[![smithery badge](https://smithery.ai/badge/@openbnb-org/mcp-server-airbnb)](https://smithery.ai/server/@openbnb-org/mcp-server-airbnb)

MCP Server for searching Airbnb and get listing details.

## Tools

1. `airbnb_search`
   - Search for Airbnb listings
   - Required Input: `location` (string)
   - Optional Inputs:
     - `placeId` (string)
     - `checkin` (string, YYYY-MM-DD)
     - `checkout` (string, YYYY-MM-DD)
     - `adults` (number)
     - `children` (number)
     - `infants` (number)
     - `pets` (number)
     - `minPrice` (number)
     - `maxPrice` (number)
     - `cursor` (string)
     - `ignoreRobotsText` (boolean)
   - Returns: Array of listings with details like name, price, location, etc.

2. `airbnb_listing_details`
   - Get detailed information about a specific Airbnb listing
   - Required Input: `id` (string)
   - Optional Inputs:
     - `checkin` (string, YYYY-MM-DD)
     - `checkout` (string, YYYY-MM-DD)
     - `adults` (number)
     - `children` (number)
     - `infants` (number)
     - `pets` (number)
     - `ignoreRobotsText` (boolean)
   - Returns: Detailed listing information including description, host details, amenities, pricing, etc.

## Features

- Respects Airbnb's robots.txt rules
- Uses cheerio for HTML parsing
- No API key required
- Returns structured JSON data
- Reduces context load by flattening and picking data

## Setup


### Installing on Claude Desktop
Before starting make sure [Node.js](https://nodejs.org/) is installed on your desktop for `npx` to work.
1. Go to: Settings > Developer > Edit Config

2. Add the following to your `claude_desktop_config.json`:

```json
{
  "mcpServers": {
    "airbnb": {
      "command": "npx",
      "args": [
        "-y",
        "@openbnb/mcp-server-airbnb"
      ]
    }
  }
}
```

To ignore robots.txt for all requests, use this version with `--ignore-robots-txt` args

```json
{
  "mcpServers": {
    "airbnb": {
      "command": "npx",
      "args": [
        "-y",
        "@openbnb/mcp-server-airbnb",
        "--ignore-robots-txt"
      ]
    }
  }
}
```
3. Restart Claude Desktop and plan your next trip that include Airbnbs!

### Other Option: Installing via Smithery

To install mcp-server-airbnb for Claude Desktop automatically via [Smithery](https://smithery.ai/server/@openbnb-org/mcp-server-airbnb):

```bash
npx -y @smithery/cli install @openbnb-org/mcp-server-airbnb --client claude
```

## Build (for devs)

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

## License

This MCP server is licensed under the MIT License.

## Disclaimer

Airbnb is a trademark of Airbnb, Inc.
OpenBnB is not related to Airbnb, Inc. or its subsidiaries