open-index/open-npm huggingface dataset:
npm package: @iflow-mcp/kazuph-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: @iflow-mcp/kazuph-mcp-taskmanager
Description: Model Context Protocol server for Task Management
Author: kazuph
Latest version: 1.0.2

# MCP TaskManager

Model Context Protocol server for Task Management. This allows Claude Desktop (or any MCP client) to manage and execute tasks in a queue-based system.

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

## Quick Start (For Users)

### Prerequisites
- Node.js 18+ (install via `brew install node`)
- 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": {
    "taskmanager": {
      "command": "npx",
      "args": ["-y", "@kazuph/mcp-taskmanager"]
    }
  }
}
```

## For Developers

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

### Installation

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

### Development 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`

Add the following to your MCP client's configuration:

```json
{
  "tools": {
    "taskmanager": {
      "args": ["tsx", "/path/to/mcp-taskmanager/index.ts"]
    }
  }
}
```

## Available Operations

The TaskManager supports two main phases of operation:

### Planning Phase
- Accepts a task list (array of strings) from the user
- Stores tasks internally as a queue
- Returns an execution plan (task overview, task ID, current queue status)

### Execution Phase
- Returns the next task from the queue when requested
- Provides feedback mechanism for task completion
- Removes completed tasks from the queue
- Prepares the next task for execution

### Parameters

- `action`: "plan" | "execute" | "complete"
- `tasks`: Array of task strings (required for "plan" action)
- `taskId`: Task identifier (required for "complete" action)
- `getNext`: Boolean flag to request next task (for "execute" action)

## Example Usage

```typescript
// Planning phase
{
  action: "plan",
  tasks: ["Task 1", "Task 2", "Task 3"]
}

// Execution phase
{
  action: "execute",
  getNext: true
}

// Complete task
{
  action: "complete",
  taskId: "task-123"
}
```
npm package: @iflow-mcp/kbb99-mcp-registry-server
Description: MCP server for retrieving MCP Servers using MCPulse
Author: Kenton Blacutt
Latest version: 0.6.2

# MCP Registry Server

[![smithery badge](https://smithery.ai/badge/@KBB99/mcp-registry-server)](https://smithery.ai/server/@KBB99/mcp-registry-server)

## Features

- **MCP Retriever**: Retrieve MCP Servers using semantic search

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

## Tools

- **retrieve_mcps**
  - Perform retrieval operations against the MCP registry.
  - Inputs:
    - `query` (string): The search query for retrieval.

## Configuration

### Installation Guide

### Installing via Smithery

To install MCP Registry Server for Claude Desktop automatically via [Smithery](https://smithery.ai/server/@KBB99/mcp-registry-server):

```bash
npx -y @smithery/cli install @KBB99/mcp-registry-server --client claude
```

### Usage with Claude Desktop

First build the server:

```bash
git clone https://github.com/KBB99/mcp-registry-server.git
cd mcp-registry-server
npm install
npm run build
```

You can confirm the server is working by running:

```bash
node ./dist/index.js
```

Add this to your `claude_desktop_config.json`:

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

## 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.

This README assumes that your server package is named `mcp-server-retriever`. Adjust the package name and installation details if they differ in your setup. Also, ensure that your server script is correctly built and that all dependencies are properly managed in your `package.json`.
npm package: @iflow-mcp/kbyk004-playwright-lighthouse-mcp
Description: A MCP server that analyzes web site performance using Playwright and Lighthouse.
Author: kbyk004
Latest version: 1.0.0

# Playwright-Lighthouse MCP Server

A MCP server that analyzes web site performance using Playwright and Lighthouse. Through the Model Context Protocol (MCP), LLMs can perform web site performance analysis.

## Features

- Performance analysis with Lighthouse
- Screenshot capture

## Setup

### Prerequisites

- Node.js 18 or higher
- npm

### Installation

```bash
# Clone the repository
git clone https://github.com/kbyk004/playwright-lighthouse-mcp.git
cd playwright-lighthouse-mcp

# Install dependencies
npm install
npx playwright install

# Build
npm run build
```

## Usage

### Debugging MCP Server

```bash
npm run inspector
```

### Integration with MCP Clients

This server is designed to be used with clients that support the Model Context Protocol (MCP). For example, it can be integrated with Claude for Desktop.

#### Configuration Example for Claude for Desktop

Add the following to the Claude for Desktop configuration file (`~/Library/Application Support/Claude/claude_desktop_config.json`):

```json
{
  "mcpServers": {
    "playwright-lighthouse": {
      "command": "node",
      "args": [
        "/path-to/playwright-lighthouse-mcp/build/index.js"
      ]
    }
  }
}
```

## Available Tools

### 1. run-lighthouse

Runs a Lighthouse performance analysis on the currently open page.

Parameters:
- `url`: The URL of the website you want to analyze
- `categories`: Array of categories to analyze (default: ["performance"])
  - Available categories: "performance", "accessibility", "best-practices", "seo", "pwa"
- `maxItems`: Maximum number of improvement items to display for each category (default: 3, max: 5)

### 2. take-screenshot

Takes a screenshot of the currently open page.

Parameters:
- `url`: The URL of the website you want to capture
- `fullPage`: If true, captures a screenshot of the entire page (default: false)

## Output Format

The analysis results include:

- Overall scores for each selected category with color indicators
- Key improvement areas grouped by category
- Path to the saved report file

## License

MIT License - see [LICENSE](LICENSE) for details
npm package: @iflow-mcp/keithah-tessie-mcp-server
Description: Tessie MCP server (v2) with summary-first tools built from the latest Tessie developer API.
Latest version: 2.0.0

# Tessie MCP Server v2

MCP server rebuilt on the latest developer.tessie.com API. Summary-first tools, composite commands, and live-tested smoke scripts.

## Quickstart
- Install (Smithery recommended): `npx -y @smithery/cli install @keithah/tessie-mcp`
- Set `TESSIE_API_KEY` (<https://dash.tessie.com/settings/api>) in your MCP client or `.env`. In Smithery UI the field appears as `accessToken`.
- Try in a client: “List my vehicles” → `get_active_context`, “Lock VIN ...” → `manage_vehicle_command` with `confirm: true`.

## Tools
- `get_active_context` — vehicle roster with next-step guidance.
- `fetch_vehicle_state` — locks, climate, battery, location snapshot.
- `fetch_vehicle_battery` — charging-focused battery view.
- `search_drives` — recent drives with optional date range.
- `get_driving_path` — coordinate series for mapping/analysis.
- `manage_vehicle_command` — lock/unlock, charging, climate, speed limit, sentry, cabin overheat, seat heat/cool, flash/honk, wake.

### Command safety
Destructive operations require `params.confirm: true`.
```json
{
  "vin": "YOUR_VIN",
  "operation": "lock",
  "params": { "confirm": true }
}
```
Non-destructive actions like `flash_lights` / `honk` skip confirmation.

## Local dev & tests
- Build stdio: `npm run build:stdio`
- Build shttp: `npm run build:shttp` or `npm run build:all`
- Tests: `npm test` (includes command validation)
- Smoke with live Tessie token: `npm run smoke` (raw client), `npm run smoke:tools` (MCP tools)

## Smithery
- Playground/dev tunnel: `npm run dev` or `npx @smithery/cli dev`
- Transports: stdio (`npm run build:stdio`), shttp (`npm run build:shttp`, default for publish)
- Docs index: <https://smithery.ai/docs/llms.txt> ; TS quickstart: `npx create-smithery@latest`
- Config schema: `.well-known/mcp-config` (expects `TESSIE_API_KEY`). Server card: `.well-known/mcp.json` (aliases in `.well-known/mcp-server.json` and `.well-known/mcp/server.json`).
- Publish/update: `npm run build:shttp` → `npx @smithery/cli publish` (uses `manifest.json`). Ensure `TESSIE_API_KEY` is provided in user config.

## Notes
- API references cached in `docs/llms-full.txt` and `docs/tessie-api-metadata.json` for offline context.
- Uses TypeScript MCP SDK and Tessie HTTPS API; all state stays in Tessie. Undo/confirmation is enforced in `manage_vehicle_command`.
- MCP design references: see `docs/glama-links.md` for glama.ai best-practice articles.
- Speed-limit operations accept `speed_limit_pin` (sensitive); avoid logging or sharing it.
- Optional debug logging: set `TESSIE_MCP_DEBUG=1` (or `true`) to emit request failures with URLs/status only (no headers/API keys); retry/backoff is built-in for 429/5xx responses.
- Tessie client caches read requests (vehicles, state, battery, drives, paths, historical states) per client instance with short TTLs (15-30s), capped size (200 entries), and VIN-scoped invalidation after commands to avoid stale state while keeping token usage low.