open-index/open-npm huggingface dataset:
npm package: @mseep/polygon-mcp
Description: A Model Context Protocol (MCP) server that provides onchain tools for Claude AI, allowing it to interact with the Polygon PoS blockchain
Author: Your Name
Latest version: 1.0.0

# Polygon MCP Server

A Model Context Protocol (MCP) server that provides onchain tools for Claude AI, allowing it to interact with the Polygon PoS blockchain.

## Features

- Call contract functions on Polygon PoS
- Get ERC20 token balances
- Transfer ERC20 tokens
- Get current gas prices

## Installation

1. Clone this repository:
```bash
git clone https://github.com/your-username/polygon-mcp.git
cd polygon-mcp
```

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

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

## Configuration

Create a `.env` file in the root directory with the following variables:

```
SEED_PHRASE="your twelve word seed phrase here"
```

## Usage

### Running the server

```bash
npm start
```

### Using with Claude

To use this MCP server with Claude, you need to add it to your MCP settings file:

For VSCode Claude extension:
```json
{
  "mcpServers": {
    "polygon": {
      "command": "node",
      "args": ["/path/to/polygon-mcp/build/index.js"],
      "env": {
        "SEED_PHRASE": "your twelve word seed phrase here"
      },
      "disabled": false,
      "autoApprove": []
    }
  }
}
```

For Claude desktop app:
```json
{
  "mcpServers": {
    "polygon": {
      "command": "node",
      "args": ["/path/to/polygon-mcp/build/index.js"],
      "env": {
        "SEED_PHRASE": "your twelve word seed phrase here"
      },
      "disabled": false,
      "autoApprove": []
    }
  }
}
```

## Available Tools

### call_contract

Call a contract function on Polygon PoS.

Parameters:
- `contractAddress`: The address of the contract to call
- `functionName`: The name of the function to call
- `functionArgs`: The arguments to pass to the function
- `abi`: The ABI of the contract
- `value` (optional): The value of MATIC to send with the transaction

### erc20_balance

Get the balance of an ERC20 token on Polygon PoS.

Parameters:
- `contractAddress`: The address of the contract to get the balance of

### erc20_transfer

Transfer an ERC20 token on Polygon PoS.

Parameters:
- `contractAddress`: The address of the contract to transfer the token from
- `toAddress`: The address of the recipient
- `amount`: The amount of tokens to transfer

### get_gas_price

Get the current gas price on Polygon PoS.

## License

MIT
npm package: @mseep/puremd-mcp
Description: Model Context Protocol (MCP) server for pure.md, the markdown delivery network for LLMs
Author: pure.md
Latest version: 1.0.3

# pure.md MCP server

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

Welcome to the Model Context Protocol (MCP) server for [pure.md](https://pure.md).

![pure.md - Markdown delivery network for LLMs](https://pure.md/assets/og.png)

[pure.md](https://pure.md) lets your scripts, APIs, apps, agents, etc reliably access web content in markdown format -- simply prefix any URL with `pure.md/`.
It avoids bot detection and renders JavaScript for SPAs, and can convert HTML, PDFs, images, and more into pure markdown. Like a CDN for markdown content, it globally caches responses for future requests to the same resource, relieving stress on origin web servers.

**Without puremd-mcp, local agents may fail to fetch web content.** puremd-mcp teaches MCP clients like Cursor, Windsurf, and Claude Desktop how to adopt the functionality of pure.md, giving them web unblocking and searching capabilities.

puremd-mcp comes with two tools:

- `unblock-url` - Extract markdown from web pages without getting blocked
- `search-web` - Search the web for a query and concatenate results into markdown

The [Model Context Protocol](https://modelcontextprotocol.io/introduction), developed by Anthropic, is an open standard that enables AI systems to seamlessly interact with an ecosystem of tooling. With it, MCP clients like Cursor, Windsurf, and Claude Desktop can learn how to use a variety of APIs and other functionality.

## Authentication

Generating an API key is an optional step that unlocks higher rate limits. If you'd like to use the pure.md MCP server anonymously, simply set your `PUREMD_API_KEY` value to empty string (`""`).

1. Sign up for a new account at [pure.md](https://pure.md) &mdash; it's free to sign up!
2. In the dashboard, generate a new API token
3. Copy the token, and use it for the `PUREMD_API_KEY` value in your MCP client's configuration file (see below)

## Client configuration

### Cursor

Add the following to your `~/.cursor/mcp.json` file:

```json
{
  "mcpServers": {
    "pure.md": {
      "command": "npx",
      "args": ["-y", "puremd-mcp"],
      "env": {
        "PUREMD_API_KEY": "<TOKEN>"
      }
    }
  }
}
```

### Windsurf

Add the following to your `./codeium/windsurf/model_config.json` file:

```json
{
  "mcpServers": {
    "pure.md": {
      "command": "npx",
      "args": ["-y", "puremd-mcp"],
      "env": {
        "PUREMD_API_KEY": "<TOKEN>"
      }
    }
  }
}
```

### Claude Desktop

Add the following to your `~/Library/Application\ Support/Claude/claude_desktop_config.json` file:

```json
{
  "mcpServers": {
    "pure.md": {
      "command": "npx",
      "args": ["-y", "puremd-mcp"],
      "env": {
        "PUREMD_API_KEY": "<TOKEN>"
      }
    }
  }
}
```

### Installing via Smithery

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

```bash
npx -y @smithery/cli install @puremd/puremd-mcp --client claude
```
npm package: @mseep/qiita-mcp-server
Description: MCP server for Qiita
Author: @2bo
Latest version: 0.1.0

# Qiita MCP Server

A Model Context Protocol (MCP) server for interacting with Qiita, the knowledge-sharing platform for engineers.

[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

## Overview

This package provides a Model Context Protocol (MCP) server that enables AI agents to interact with the Qiita API. It allows for creating, reading, and updating articles on Qiita through standardized MCP tools.

MCP is an open protocol for building AI agents that can use external tools and services. This server implements the MCP specification to provide tools for working with Qiita content.

## Provided Tools

The server provides the following MCP tools:

| Tool Name | Description |
|-----------|-------------|
| `get_my_qiita_articles` | Get current authenticated user's Qiita articles |
| `get_qiita_item` | Get a specific Qiita article by its ID |
| `post_qiita_article` | Create a new article on Qiita |
| `update_qiita_article` | Update an existing Qiita article |
| `get_qiita_markdown_rules` | Get Qiita markdown syntax rules and cheat sheet |

## Usage

### Prerequisites

- Node.js (>=20.0.0)
- A Qiita account with API access token
  - You can generate a Qiita API token by visiting: https://qiita.com/settings/tokens/new

### Usage with VS Code

1. Create a `.vscode/mcp.json` file in your project with the following content:

```json
{
  "inputs": [
    {
      "type": "promptString",
      "id": "qiita-api-token",
      "description": "Qiita API Token",
      "password": true
    }
  ],
  "servers": {
    "qiita-mcp-server": {
      "type": "stdio",
      "command": "npx",
      "args": ["@2bo/qiita-mcp-server"],
      "env": {
        "QIITA_API_TOKEN": "${input:qiita-api-token}"
      }
    }
  }
}
```

## Development

### Setup

1. Clone the repository:

```bash
git clone https://github.com/2bo/qiita-mcp-server.git
cd qiita-mcp-server
```

2. Install dependencies:

```bash
npm install
```

3. Set up your environment:

- `npm run dev` - Run TypeScript in watch mode for development
- `npm run build` - Build the project
- `npm run prepare` - Prepare the package for publishing

### Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

## License

This project is licensed under the MIT License - see the LICENSE file for details.