open-index/open-npm huggingface dataset:
npm package: @iflow-mcp/panktishah62-figma-mcp
Description: MCP server for interacting with Figma designs
Latest version: 0.0.1

# mcp-copy-web-ui

This is an MCP server that helps download and analyze websites for UI/UX inspiration. It captures the complete HTML content of a website, including all CSS, images, and other resources, making them available for analysis by Claude.

## Features

- Downloads complete webpage content
- Inlines all CSS styles
- Converts images to base64 data URIs
- Resolves and inlines all external resources
- Makes the complete webpage available for AI analysis

## Tools

### get_web_inspiration
Downloads and analyzes a website for UI/UX inspiration. Takes a URL as input and returns the complete HTML with all resources inlined.

Example usage in Claude:
```
I'd like to get inspiration from example.com's design
```

## How to Use

### NPX

```json
{
  "mcpServers": {
    "mediaProcessor": {
      "command": "npx",
      "args": [
        "-y",
        "create-mcp-server@latest"
      ]
    }
  }
}
```
npm package: @iflow-mcp/pauldub-appsignal-mcp
Description: MCP server for AppSignal error monitoring integration
Latest version: 0.1.0

# AppSignal MCP

A Model Context Protocol (MCP) server for AppSignal monitoring API integration. This server allows AI assistants to directly query and fetch error and performance data from AppSignal through the MCP protocol.

## Features

- Fetch details about specific error or performance samples
- Search for errors, performance samples, or both with flexible filters
- Integration with AppSignal's Error and Performance Monitoring APIs

## Prerequisites

- [Bun](https://bun.sh/) runtime
- AppSignal account and API token
- Application ID from your AppSignal dashboard

## Installation

```bash
# Clone the repository
git clone https://github.com/pauldub/appsignal-mcp.git
cd appsignal-mcp

# Install dependencies
bun install
```

## Configuration

Create a `.env` file in the root directory with your AppSignal credentials:

```env
# Server configuration
PORT=3000
LOG_LEVEL=info

# AppSignal configuration
APPSIGNAL_API_TOKEN=your-api-token
```

## Usage

### Starting the Server

```bash
# Run the server
bun start

# Development mode with auto-reload
bun dev

# Run tests
bun test

# Build a standalone executable
bun run build
```

### CLI Options

```bash
appsignal-mcp --appsignal-api-token your-token
```

Available options:
- `--appsignal-api-token <token>` - AppSignal API token
- `--log-level <level>` - Logging level (debug, info, warn, error)
- `--port <port>` - Server port number

## MCP Tools

### 1. get_sample

Gets details about a specific sample by ID (error or performance).

**Parameters:**
- `sampleId` (string, required): The AppSignal sample ID
- `appId` (string, required): The AppSignal application ID

### 2. search_samples

Searches for samples in an application with optional filters.

**Parameters:**
- `appId` (string, required): The AppSignal application ID
- `sample_type` (string, optional): Type of samples to search - "all", "errors", or "performance" (defaults to "errors")
- `exception` (string, optional): Filter by exception name (e.g., "NoMethodError") - only applicable for error samples
- `action_id` (string, optional): Filter by action name (e.g., "BlogPostsController-hash-show")
- `since` (string/number, optional): Start timestamp in UTC (timestamp or ISO format)
- `before` (string/number, optional): End timestamp in UTC (timestamp or ISO format)
- `limit` (number, optional): Maximum number of samples to return (defaults to 10)
- `count_only` (boolean, optional): Only return the count, not the samples

## Claude Integration

To use this MCP server with Claude, create a `.mcp.json` file in your Claude Code workspace:

```json
{
  "mcpServers": {
    "appsignal-mcp": {
      "type": "stdio",
      "command": "bun",
      "args": [
        "run",
        "start"
      ],
      "env": {
        "APPSIGNAL_API_TOKEN": "your-api-token"
      }
    }
  }
}
```

## License

MIT
npm package: @iflow-mcp/pelikhan-micro-mcp
Description: With this library, you will be able to define MCP tools in TypeScript (blocks not yet) and use the bridge script to connect to a MCP client via stdio.
Latest version: 1.0.2

# micro-mcp
## Turn your BBC micro:bit into a [Model Context Protocol](https://modelcontextprotocol.io/introduction) (MCP) server

With this library, you will be able to define MCP tools in TypeScript (blocks not yet)
and use the bridge script to connect to a MCP client via stdio.

https://github.com/user-attachments/assets/48418354-385a-45e9-bee1-7e36633dd243

## Example

This example shows how to define a tool that displays a number on the micro:bit's LED matrix.

```ts
mcp.tool({
    definition: {
        name: "show_number",
        description: "Show a number on the 5 x 5 LED matrix",
        inputSchema: {
            type: "object",
            properties: {
                number: { type: "integer", description: "Integer to show" }
            },
            required: ["number"]
        },
        annotations: {
            title: "Show Number",
            idempotentHint: true,
        }
    },
    handler: (args: { number: number }) => {
        const number = args.number || 0;
        basic.showNumber(number);
        return `ok`;
    }
})
mcp.startServer()
```

## Visual Studio Code

To test out the MCP server, you can use the `bridge` script in this repository.

- install dependencies
```sh
npm ci
```

- create a `.vscode/mcp.json` file in the root of this repository with the following content:

```json
{
    "servers": {
        "micro-mcp": {
            "type": "stdio",
            "command": "node",
            "args": ["${workspaceFolder}/bridge.mjs"]
        }
    }
}
```

- open GitHub Copilot Chat
- open the `mcp.json` file and start the server
- click on the `Tools` icon and make sure your tool are listed and selected
- prompt away!

## Use as Extension

This repository can be added as an **extension** in MakeCode.

* open [https://makecode.microbit.org/](https://makecode.microbit.org/)
* click on **New Project**
* click on **Extensions** under the gearwheel menu
* search for **https://github.com/pelikhan/micro-mcp** and import

## Edit this project

Use Visual Studio Code to edit this project.

#### Metadata (used for search, rendering)

* for PXT/microbit

![ChatGPT Image Jun 4, 2025, 02_22_06 PM](https://github.com/user-attachments/assets/b1445cad-2a9a-4dfd-be80-551c72399be4)
npm package: @iflow-mcp/penrose-mcp
Description: An MCP server for Penrose
Latest version: 0.1.0

# Penrose MCP Server

A Model Context Protocol (MCP) server for [Penrose](https://penrose.cs.cmu.edu/) - Create beautiful mathematical diagrams through natural language.

## Overview

This MCP server provides tools and resources for creating mathematical diagrams using Penrose's domain-specific languages:

- **Domain (DSL)**: Define mathematical types and relationships
- **Substance**: Describe mathematical objects and their relationships
- **Style**: Specify visual representation rules

## Project Structure

- `.topos/`: Research materials and documentation (gitignored)
  - `penrose-research/`: Design documents and specifications
  - `mcp-examples/`: Reference MCP server implementations
  - `mcp-spec/`: Official MCP protocol documentation

## Development

Use the justfile to access documentation and reference materials:

```bash
# List all available commands
just --list

# View the server architecture
just architecture

# Access MCP specifications
just mcp-spec
```

## License

MIT License - See LICENSE file for details