open-index/open-npm huggingface dataset:
npm package: @iflow-mcp/mcp-obsidian
Description: Model Context Protocol server for Obsidian Vaults
Author: kazuph
Latest version: 1.0.2

# MCP Obsidian

Model Context Protocol server for Obsidian vault integration. This allows Claude Desktop (or any MCP client) to search and read your Obsidian notes.

## Quick Start (For Users)

### Prerequisites
- Node.js 18+ (install via `brew install node`)
- Obsidian vault
- Claude Desktop (install from https://claude.ai/desktop)

### Configuration

1. Open your Claude Desktop configuration file at:
`~/Library/Application Support/Claude/claude_desktop_config.json`

You can find this through the Claude Desktop menu:
1. Open Claude Desktop
2. Click Claude on the Mac menu bar
3. Click "Settings"
4. Click "Developer"

2. Add the following to your configuration:

```json
{
  "tools": {
    "obsidian": {
      "command": "npx",
      "args": ["-y", "@kazuph/mcp-obsidian"],
      "env": {
        "OBSIDIAN_VAULT_PATH": "/path/to/your/obsidian/vault"
      }
    }
  }
}
```

Note: Replace `/path/to/your/obsidian/vault` with your actual Obsidian vault path.

## For Developers

### Prerequisites
- Node.js 18+ (install via `brew install node`)
- Obsidian vault
- Claude Desktop (install from https://claude.ai/desktop)
- tsx (install via `npm install -g tsx`)

## Installation

```bash
git clone https://github.com/kazuph/mcp-obsidian.git
cd mcp-obsidian
npm install
npm run build
```

## Configuration

1. Make sure Claude Desktop is installed and running.

2. Install tsx globally if you haven't:
```bash
npm install -g tsx
# or
pnpm add -g tsx
```

3. Modify your Claude Desktop config located at:
`~/Library/Application Support/Claude/claude_desktop_config.json`

You can easily find this through the Claude Desktop menu:
1. Open Claude Desktop
2. Click Claude on the Mac menu bar
3. Click "Settings"
4. Click "Developer"

Add the following to your MCP client's configuration:

```json
{
  "tools": {
    "obsidian": {
      "args": ["tsx", "/path/to/mcp-obsidian/index.ts"],
      "env": {
        "OBSIDIAN_VAULT_PATH": "/path/to/your/obsidian/vault"
      }
    }
  }
}
```

## Available Tools

- `obsidian_read_notes`: Read the contents of multiple notes. Each note's content is returned with its path as a reference.
- `obsidian_search_notes`: Search for notes by name (case-insensitive, supports partial matches and regex).
- `obsidian_read_notes_dir`: List the directory structure under a specified path.
- `obsidian_write_note`: Create a new note at the specified path.
npm package: @iflow-mcp/mcp-openai
Description: MCP server for simple interaction with OpenAI API
Author: mzxrai
Latest version: 0.1.1

# MCP OpenAI Server

A Model Context Protocol (MCP) server that lets you seamlessly use OpenAI's models right from Claude.

## Features

- Direct integration with OpenAI's chat models
- Support for multiple models including:
  - gpt-4o
  - gpt-4o-mini
  - o1-preview
  - o1-mini
- Simple message passing interface
- Basic error handling

## Prerequisites

- [Node.js](https://nodejs.org/) >= 18 (includes `npm` and `npx`)
- [Claude Desktop app](https://claude.ai/download)
- [OpenAI API key](https://platform.openai.com/api-keys)

## Installation

First, make sure you've got the [Claude Desktop app](https://claude.ai/download) installed and you've requested an [OpenAI API key](https://platform.openai.com/api-keys).

Add this entry to your `claude_desktop_config.json` (on Mac, you'll find it at `~/Library/Application\ Support/Claude/claude_desktop_config.json`):

```json
{
  "mcpServers": {
    "mcp-openai": {
      "command": "npx",
      "args": ["-y", "@mzxrai/mcp-openai@latest"],
      "env": {
        "OPENAI_API_KEY": "your-api-key-here (get one from https://platform.openai.com/api-keys)"
      }
    }
  }
}
```

This config lets Claude Desktop fire up the OpenAI MCP server whenever you need it.

## Usage

Just start chatting with Claude and when you want to use OpenAI's models, ask Claude to use them. 

For example, you can say,

```plaintext
Can you ask o1 what it thinks about this problem?
```

or,

```plaintext
What does gpt-4o think about this?
```

The server currently supports these models:

- gpt-4o (default)
- gpt-4o-mini
- o1-preview
- o1-mini

### Tools

1. `openai_chat`
   - Sends messages to OpenAI's chat completion API
   - Arguments: 
     - `messages`: Array of messages (required)
     - `model`: Which model to use (optional, defaults to gpt-4o)

## Problems

This is alpha software, so may have bugs. If you have an issue, check Claude Desktop's MCP logs:

```bash
tail -n 20 -f ~/Library/Logs/Claude/mcp*.log
```

## Development

```bash
# Install dependencies
pnpm install

# Build the project
pnpm build

# Watch for changes
pnpm watch

# Run in development mode
pnpm dev
```

## Requirements

- Node.js >= 18
- OpenAI API key

## Verified Platforms

- [x] macOS
- [ ] Linux

## License

MIT

## Author

[mzxrai](https://github.com/mzxrai)
npm package: @iflow-mcp/mcp-pattern-language
Description: A Pattern Language MCP server providing structured coding instructions
Latest version: 0.0.3

# My Rules

An MCP server for all my rules, prompts, etc etc. Allows agents to call rules on demand. 

> There's no point filling 4 paragraphs of instructions for how to write tests if your current session isn't going to write a test.

Spiritually similar to Cursor's rules.

## Usage

### Claude Code

```
claude mcp add --transport http rules https://mcp.cianfrani.dev/mcp
```

### Cursor

[![Install MCP Server](https://cursor.com/deeplink/mcp-install-dark.svg)](https://cursor.com/install-mcp?name=rules&config=eyJjb21tYW5kIjoibnB4IG1jcC1yZW1vdGUgaHR0cHM6Ly9tY3AuY2lhbmZyYW5pLmRldi9tY3AifQ%3D%3D)

### Claude Desktop 

```json
{
    "rules": {
      "command": "npx",
      "args": [
        "mcp-remote",
        "https://mcp.cianfrani.dev/mcp"
      ]
    }
}
```

## What's It Do? 

Allows coding agents to lookup rules on demand within the context of their current task. 

```
> write a test for @calc.py
  ⎿  Read calc.py (26 lines)

⏺ rules:get_rules_for_writing_tests (MCP)(language: "python")
  ⎿  - Before testing a protected method, ask "Can this logic be adequately tested through the public interface?". If yes, don't test the protected method directly.
     If no, continue testing the protected method.
     - Remember to write tests using the Arrange, Act, Assert pattern.
     … +12 lines (ctrl+r to expand)

⏺ Write(test_calc.py)
```

## Why? 

- It's really annoying trying to carry all these little notes between projects/IDEs.
- I don't want to have to manually invoke rules. 

## How's It Work? 

Clearly-defined tool descriptions allow the agent to fetch rules on demand, only if they appear to be relevant. 


## What Doesn't work? 

- Patterns must be associated with a specific action. For example, "writing tests", "authoring UI", "reviewing a PR". 
- The agent ultimately decides if it's going to call the tool. Sometimes it does. Sometimes it doesn't. 


## Tools 


1. `get_rules_for_writing_tests`
   - Use when: writing any type of test, 
   - Inputs:
     - `language` (string)
2. `get_rules_for_composing_ui`
  - Use when: creating new frontend components

## Prompts

> In Claude Code, invoke prompts as slash commands. 

1. `pr-review`
  - Use when: you want feedback on a unit of work 
  - /pr-review
  - See [resources/pr-review.md](./resources/pr-review.md) for the full template.

## Resources

- [Deploying this shit on netlify](https://developers.netlify.com/guides/write-mcps-on-netlify/)

## Dev 
1. Start the server

```
npm run dev
```

2. Open MCP inspector
```
npm run inspect
```
npm package: @iflow-mcp/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: @iflow-mcp/mcp-pocket
Description: Model Context Protocol server for Pocket API - Access and manage your Pocket articles through Claude
Author: kazuph
Latest version: 1.0.4

# MCP Pocket

This is a connector to allow Claude Desktop (or any MCP client) to fetch your saved articles from Pocket API.

<a href="https://glama.ai/mcp/servers/1e2o9ooltu"><img width="380" height="200" src="https://glama.ai/mcp/servers/1e2o9ooltu/badge" alt="@kazuph/mcp-pocket MCP server" /></a>

## Prerequisites
- Node.js (install via `brew install node`)
- Claude Desktop (install from https://claude.ai/desktop)
- Pocket API credentials

## Quick Start

1. Modify your Claude Desktop config located here:
`~/Library/Application\ Support/Claude/claude_desktop_config.json`

You can easily find this through the Claude Desktop menu:
1. Open Claude Desktop
2. Click Claude on the Mac menu bar
3. Click "Settings"
4. Click "Developer"

If you don't have this config, you can create an empty file at this location.

Add the following to the config file, replacing the credentials with your own:

```json
{
  "mcpServers": {
    "pocket": {
      "command": "npx",
      "args": ["-y", "@kazuph/mcp-pocket"],
      "env": {
        "POCKET_CONSUMER_KEY": "your-pocket-consumer-key",
        "POCKET_ACCESS_TOKEN": "your-pocket-access-token"
      }
    }
  }
}
```

## Development Setup

1. Clone this repository and install dependencies:
```bash
git clone https://github.com/kazuph/mcp-pocket.git
cd mcp-pocket
npm install
```

2. For development, use this configuration instead:
```json
{
  "mcpServers": {
    "pocket": {
      "command": "npx",
      "args": ["tsx", "/path/to/mcp-pocket/index.ts"],
      "env": {
        "POCKET_CONSUMER_KEY": "your-pocket-consumer-key",
        "POCKET_ACCESS_TOKEN": "your-pocket-access-token"
      }
    }
  }
}
```

### Development Commands

```bash
# Build TypeScript
npm run build

# Watch mode for development
npm run watch

# Publish to npm
npm login
npm publish
```

## Available Commands

The following MCP tools will be available in Claude Desktop:

- `pocket_get_articles`: Fetch your saved articles from Pocket API. Returns title, URL, and excerpt for each article.
- `pocket_mark_as_read`: Mark a specific article as read (archived) in your Pocket account using its item ID.

## Getting Pocket API Credentials

For detailed instructions on obtaining your Pocket API credentials, please refer to [Issue #2](https://github.com/kazuph/mcp-pocket/issues/2).

Quick steps:
1. Create a new app at [Pocket Developer Portal](https://getpocket.com/developer/apps/new)
2. Follow the authentication process to get your Consumer Key and Access Token

## License

MIT
npm package: @iflow-mcp/mcp-puppeteer
Description: MCP server for browser automation using Puppeteer
Author: Anthropic, PBC
Latest version: 0.6.2

# Puppeteer

A Model Context Protocol server that provides browser automation capabilities using Puppeteer. This server enables LLMs to interact with web pages, take screenshots, and execute JavaScript in a real browser environment.

## Components

### Tools

- **puppeteer_navigate**

  - Navigate to any URL in the browser
  - Input: `url` (string)

- **puppeteer_screenshot**

  - Capture screenshots of the entire page or specific elements
  - Inputs:
    - `name` (string, required): Name for the screenshot
    - `selector` (string, optional): CSS selector for element to screenshot
    - `width` (number, optional, default: 800): Screenshot width
    - `height` (number, optional, default: 600): Screenshot height

- **puppeteer_click**

  - Click elements on the page
  - Input: `selector` (string): CSS selector for element to click

- **puppeteer_hover**

  - Hover elements on the page
  - Input: `selector` (string): CSS selector for element to hover

- **puppeteer_fill**

  - Fill out input fields
  - Inputs:
    - `selector` (string): CSS selector for input field
    - `value` (string): Value to fill

- **puppeteer_select**

  - Select an element with SELECT tag
  - Inputs:
    - `selector` (string): CSS selector for element to select
    - `value` (string): Value to select

- **puppeteer_evaluate**
  - Execute JavaScript in the browser console
  - Input: `script` (string): JavaScript code to execute

### Resources

The server provides access to two types of resources:

1. **Console Logs** (`console://logs`)

   - Browser console output in text format
   - Includes all console messages from the browser

2. **Screenshots** (`screenshot://<name>`)
   - PNG images of captured screenshots
   - Accessible via the screenshot name specified during capture

## Key Features

- Browser automation
- Console log monitoring
- Screenshot capabilities
- JavaScript execution
- Basic web interaction (navigation, clicking, form filling)

## Configuration to use Puppeteer Server

Here's the Claude Desktop configuration to use the Puppeter server:

### Docker

**NOTE** The docker implementation will use headless chromium, where as the NPX version will open a browser window.

```json
{
  "mcpServers": {
    "puppeteer": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "--init",
        "-e",
        "DOCKER_CONTAINER=true",
        "mcp/puppeteer"
      ]
    }
  }
}
```

### NPX

```json
{
  "mcpServers": {
    "puppeteer": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-puppeteer"]
    }
  }
}
```

## Build

Docker build:

```bash
docker build -t mcp/puppeteer -f src/puppeteer/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.