open-index/open-npm huggingface dataset:
npm package: @iflow-mcp/derekprovance-lifeup-mcp-server
Description: MCP Server for LifeUp Cloud API integration with Claude
Author: Derek Provance
Latest version: 1.1.0

# LifeUp MCP Server

An MCP server that enables Claude to interact with LifeUp Cloud API on your local network. Supports task creation, querying, and achievement matching.

## Quick Start

1. **Install**

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

2. **Configure**

    ```bash
    cp .env.example .env
    ```

    Update `LIFEUP_HOST` to your Android device's IP (find it in LifeUp Settings → HTTP API)

3. **Run**
    ```bash
    npm run start
    ```

## Available Tools

**Task Management**

-   `create_task` - Create a new task with rewards
-   `list_all_tasks` - List all tasks
-   `search_tasks` - Filter tasks by criteria
-   `get_task_history` - View completed tasks
-   `get_task_categories` - List task categories

**Achievements**

-   `list_achievements` - List all achievements
-   `match_task_to_achievements` - Find matching achievements for a task

**User Info**

-   `get_user_info` - User profile and level
-   `list_skills` - Skills and progression
-   `get_coin_balance` - Current coins

**Shop**

-   `list_shop_items` - Browse items
-   `get_shop_categories` - Item categories
-   `search_shop_items` - Search items

**Safe Mutations**

-   `edit_task` - Edit existing tasks
-   `create_achievement` - Create new achievements
-   `update_achievement` - Update achievements
-   `delete_achievement` - Delete achievements
-   `add_shop_item` - Create shop items
-   `edit_shop_item` - Modify shop items
-   `apply_penalty` - Apply resource penalties
-   `edit_skill` - Manage skills

## Environment Variables

```bash
LIFEUP_HOST=10.103.2.235      # Device IP
LIFEUP_PORT=13276              # API port
LIFEUP_API_TOKEN=              # Optional auth token
DEBUG=false                     # Set to 'true' for logging
SAFE_MODE=false                 # Set to 'true' to disable edit/delete mutations
```

## Troubleshooting

**Connection failed?**

-   Ensure LifeUp is running with HTTP API enabled
-   Verify both devices are on the same network
-   Check and update `LIFEUP_HOST` in `.env`

**Achievement data unavailable?**

-   This is expected for some LifeUp versions - the server falls back to categories

**Debug errors?**

```bash
DEBUG=true npm run start
```

## Safe Mode

SAFE_MODE provides protection against accidental data modification:

-   **Enabled** (SAFE_MODE=true): Allows read operations and creating new entities (tasks, achievements, shop items). Blocks editing and deleting existing data.
-   **Disabled** (SAFE_MODE=false): Full access to all 20 tools including edits and deletions.

Useful for testing or when you want Claude to help plan/create but not modify existing data.

## Links

-   [LifeUp Docs](https://docs.lifeupapp.fun/en/#/guide/api)
-   [LifeUp SDK](https://github.com/Ayagikei/LifeUp-SDK)
-   [CLAUDE.md](./CLAUDE.md) - Developer guide

## License

MIT
npm package: @iflow-mcp/devtoolcss-chrome-inspector-mcp
Description: MCP server for Chrome DevTools CSS inspection
Latest version: 0.0.2

# Chrome Inspector MCP

This gives agents **DOM Elements**, **CSS Rules**, and **Computed Style**, the tools that `chrome-devtools-mcp` doesn't provide.

This redesign of DevTools MCP aims to enable agents to take over DevTools for complex debugging. Any suggestions are welcomed. Current directions includes:

- **Agent Ergonomics**: Building directly on [Chrome DevTools Protocol (CDP)](https://chromedevtools.github.io/devtools-protocol/), designing for agent needs, not library constraints
- **Extensibility**: Making it easy for users (and agents?) to hack and customize their own toolsets

## Demo

https://github.com/user-attachments/assets/c880a415-f35a-4fc4-93c4-001030116b90

## Installation

1. Install the extension from [Releases](https://github.com/devtoolcss/chrome-inspector-mcp/releases)

2. Add the following config to your MCP client:

```json
{
  "mcpServers": {
    "chrome-inspector": {
      "command": "npx",
      "args": ["-y", "chrome-inspector-mcp@latest"]
    }
  }
}
```

## Tools

- [`getTabs`](./tools.md#gettabs)
- [`selectTab`](./tools.md#selecttabs)
- [`getNodes`](./tools.md#getnodes)
- [`getMatchedStyles`](./tools.md#getmatchedstyles)
- [`getComputedStyle`](./tools.md#getcomputedstyle)
- [`getOuterHTML`](./tools.md#getouterhtml)

### TODO

- console js & message
- device emulation

### Guidelines

1. **Generalization**: Prefer taking programmatic expression. Let models code.

2. **Filtering**: When raw output could be large, provide built-in filtering logic.

## How it works

When Chrome starts, the extension's background worker polls a specific port every few seconds. When the MCP server starts at the address they connect. By manifest v3, one background worker serves one profile, so the MCP server can access all its tabs (TODO: filtering).

Currently, the extension handles all DevTools logic and the MCP server is just a relay. Yet Chrome extension has many restrictions, so I planed to forward `chrome` API and keep things in MCP's Nodejs runtime following [playwright-mcp's design](https://github.com/microsoft/playwright-mcp/tree/main/extension).

The inspection logic is implemented in [chrome-inspector](https://github.com/devtoolcss/chrome-inspector), a programming interface wrapping [CDP](https://chromedevtools.github.io/devtools-protocol/) to DOM methods.
npm package: @iflow-mcp/dishant27-medium-mcp-server
Description: Model Context Protocol Server for Medium API Integration
Author: Dishant Kumar
Latest version: 1.0.0

# <img src="https://cdn-static-1.medium.com/_/fp/icons/Medium-Avatar-500x500.svg" alt="Medium Logo" width="32" height="32"> Medium MCP Server

## Overview
Medium MCP (Model Context Protocol) is an innovative solution for programmatically interacting with Medium's content ecosystem, enabling intelligent and context-aware content retrieval.

## 📖 Deep Dive Article
Want to understand the full story behind Medium MCP? Check out the comprehensive article:

[From Thought to Published: How MediumMCP Streamlines the AI-to-Medium Platform Workflow](https://dishantraghav27.medium.com/from-thought-to-published-how-mediummcp-streamlines-the-ai-to-medium-platform-workflow-9e436159d1a2)

## Key Features
- Intelligent content querying
- AI-powered content extraction
- Context-aware analysis

## Technology Stack
- TypeScript
- Model Context Protocol (MCP)
- Advanced Content Parsing

## Getting Started

### Prerequisites
- Node.js (v16 or later)
- npm or yarn
- Medium API credentials

### Installation
```bash
# Clone the repository
git clone https://github.com/Dishant27/medium-mcp-server.git

# Navigate to the project directory
cd medium-mcp-server

# Install dependencies
npm install
npm package: @iflow-mcp/diulela-browser-tools-mcp
Description: MCP (Model Context Protocol) server for browser tools integration
Author: AgentDesk AI
Latest version: 1.2.0

# Browser Tools MCP Server

A Model Context Protocol (MCP) server that provides AI-powered browser tools integration. This server works in conjunction with the Browser Tools Server to provide AI capabilities for browser debugging and analysis.

## Features

- MCP protocol implementation
- Browser console log access
- Network request analysis
- Screenshot capture capabilities
- Element selection and inspection
- Real-time browser state monitoring
- Accessibility, performance, SEO, and best practices audits

## Prerequisites

- Node.js 14 or higher
- Browser Tools Server running
- Chrome or Chromium browser installed (required for audit functionality)

## Installation

```bash
npx @agentdeskai/browser-tools-mcp
```

Or install globally:

```bash
npm install -g @agentdeskai/browser-tools-mcp
```

## Usage

1. First, make sure the Browser Tools Server is running:

```bash
npx @agentdeskai/browser-tools-server
```

2. Then start the MCP server:

```bash
npx @agentdeskai/browser-tools-mcp
```

3. The MCP server will connect to the Browser Tools Server and provide the following capabilities:

- Console log retrieval
- Network request monitoring
- Screenshot capture
- Element selection
- Browser state analysis
- Accessibility and performance audits

## MCP Functions

The server provides the following MCP functions:

- `mcp_getConsoleLogs` - Retrieve browser console logs
- `mcp_getConsoleErrors` - Get browser console errors
- `mcp_getNetworkErrors` - Get network error logs
- `mcp_getNetworkSuccess` - Get successful network requests
- `mcp_getNetworkLogs` - Get all network logs
- `mcp_getSelectedElement` - Get the currently selected DOM element
- `mcp_runAccessibilityAudit` - Run a WCAG-compliant accessibility audit
- `mcp_runPerformanceAudit` - Run a performance audit
- `mcp_runSEOAudit` - Run an SEO audit
- `mcp_runBestPracticesAudit` - Run a best practices audit

## Integration

This server is designed to work with AI tools and platforms that support the Model Context Protocol (MCP). It provides a standardized interface for AI models to interact with browser state and debugging information.

## License

MIT
npm package: @iflow-mcp/divmgl-clancey
Description: MCP server that indexes Claude Code and Codex conversations for semantic search
Author: Dexter Miguel
Latest version: 0.3.3

# Clancey

[![CI](https://github.com/divmgl/clancey/actions/workflows/ci.yml/badge.svg)](https://github.com/divmgl/clancey/actions/workflows/ci.yml)
[![Publish to npm](https://github.com/divmgl/clancey/actions/workflows/publish.yml/badge.svg)](https://github.com/divmgl/clancey/actions/workflows/publish.yml)

An MCP server that indexes your Claude Code and Codex conversations for semantic search. Find solutions, decisions, and context from previous coding sessions.

## Features

- **Semantic Search** - Find conversations by meaning, not just keywords
- **Auto-Indexing** - Automatically indexes new conversations as they happen
- **Local & Private** - Everything runs locally using LanceDB and a Huggingface model
- **Resumable** - Indexing saves progress incrementally, picks up where it left off
- **Fast** - Uses all-MiniLM-L6-v2 for quick, lightweight embeddings

## Installation

Use the setup for your client:

<details>
<summary>Claude Code</summary>

Add to your Claude Code MCP settings (`~/.claude/settings.json`):

```json
{
  "mcpServers": {
    "clancey": {
      "command": "npx",
      "args": ["-y", "clancey"]
    }
  }
}
```

Restart Claude Code.

</details>

<details>
<summary>Codex</summary>

Add to your Codex config (`~/.codex/config.toml`):

```toml
[mcp_servers.clancey]
command = "npx"
args = ["-y", "clancey"]
```

Restart Codex.

</details>

## MCP Tools

### `search_conversations`

Search through your indexed conversations semantically.

```
query: "how did I fix the auth bug"
limit: 5
project: "my-app"  # optional filter
```

### `index_conversations`

Manually trigger conversation indexing.

```
force: true  # reindex everything
```

### `index_status`

Get statistics about indexed conversations.

## How It Works

1. Scans conversation files from `~/.claude/projects/` and `~/.codex/sessions/`
2. Parses JSONL events into user/assistant messages
3. Chunks long conversations into searchable segments
4. Generates embeddings with `all-MiniLM-L6-v2`
5. Stores vectors in LanceDB at `~/.clancey/conversations.lance`
6. Watches both source directories and incrementally re-indexes changed `.jsonl` files

Data is stored in `~/.clancey/`. Logs are at `~/.clancey/clancey.log`.

## Development

```bash
git clone https://github.com/divmgl/clancey.git
cd clancey
bun install
bun run build
```

## Tech Stack

- [LanceDB](https://lancedb.com/) - Vector database
- [Huggingface Transformers.js](https://huggingface.co/docs/transformers.js) - Embedding model
- [MCP SDK](https://github.com/modelcontextprotocol/sdk) - Claude integration
- [Chokidar](https://github.com/paulmillr/chokidar) - File watching

## License

MIT