open-index/open-npm huggingface dataset:
npm package: @iflow-mcp/the-focus-ai-mastodon-mcp
Description: MCP server for Mastodon integration
Latest version: 1.0.0

# Mastodon MCP

A [Model Context Protocol](https://github.com/thefocus/modelcontextprotocol) server that provides tools for interacting with Mastodon. Currently supports creating toots with optional media attachments.

## Features

- Create toots with customizable visibility and content warnings
- Upload and attach media files (images, videos, audio)
- Add alt text/descriptions to media attachments
- Schedule toots for a future time
- Secure credential management using environment variables or 1Password CLI

## Prerequisites

- Node.js 18+
- pnpm
- A Mastodon account and API access token
- Optionally, 1Password CLI (`op`) installed and configured if using 1Password for credential management.

## Installation

```bash
# Clone the repository
git clone [repository-url]
cd mastodon-mcp

# Install dependencies
pnpm install

# Build the project
pnpm build
```

## Configuration

The tool requires a Mastodon API token. You can provide this token in one of the following ways:

1.  **Environment Variable (Recommended for simplicity)**:
    Set the `MASTODON_ACCESS_TOKEN` environment variable:
    ```bash
    export MASTODON_ACCESS_TOKEN="your_mastodon_api_token"
    ```
2.  **1Password**: Store your token at:
    - `op://Personal/Floss.Social Key/notesPlain`

You can optionally set the Mastodon instance URL via environment variable:

```bash
export MASTODON_INSTANCE_URL="https://your.instance.social"
```

If not set, it defaults to `https://floss.social`.

## Usage

Start the MCP server:

```bash
pnpm start
```

The server exposes a single tool `mastodon_create_toot` with the following parameters:

- `content` (required): The text content of your toot
- `visibility`: One of "public", "unlisted", "private", or "direct" (default: "public")
- `sensitive`: Boolean flag for sensitive content (default: false)
- `spoiler_text`: Warning text shown before the content (default: "")
- `media_file`: Path to a media file to attach
- `media_description`: Alt text/description for the attached media
- `scheduled_at`: Optional ISO 8601 datetime to schedule the toot for a future time (e.g., "2024-07-04T10:00:00-07:00")

### Example Usage with MCP Inspector

1. Start the inspector:

```bash
npx @modelcontextprotocol/inspector node dist/mcp-server.js
```

2. Open http://localhost:5173 in your browser

3. Use the tool with parameters like:

```json
{
  "content": "Hello from MCP!",
  "visibility": "public",
  "media_file": "/path/to/image.jpg",
  "media_description": "A beautiful sunset",
  "scheduled_at": "2025-01-01T12:00:00Z"
}
```

## Development

```bash
# Run in development mode with auto-reloading
pnpm dev

# Build the project
pnpm build

# Run the built server
pnpm start
```

## Security

- No credentials are hardcoded in the codebase
- API tokens can be securely managed via environment variables or retrieved from 1Password.
- API responses are git-ignored to prevent accidental credential leaks

## License

ISC
npm package: @iflow-mcp/theycallmeholla-schema-org-mcp
Description: MCP server for schema.org vocabulary
Latest version: 0.1.0

# Schema.org MCP Server

An MCP (Model Context Protocol) server that provides access to schema.org vocabulary for structured data.

## Features

- **Get Schema Type**: Retrieve detailed information about any schema.org type
- **Search Schemas**: Search for schema types by keyword
- **Type Hierarchy**: Explore inheritance relationships between types
- **Type Properties**: List all properties available for a type (including inherited)
- **Generate Examples**: Create example JSON-LD for any schema type

## Installation

```bash
# Clone the repository
git clone https://github.com/yourusername/schema-org-mcp.git
cd schema-org-mcp

# Install dependencies
npm install

# Build the project
npm run build

# Run the server
npm start
```

## Usage

### With Claude Desktop

Add this to your Claude Desktop configuration (`~/Library/Application Support/Claude/claude_desktop_config.json`):

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

### Available Tools

#### 1. get_schema_type
Get detailed information about a schema.org type.

```json
{
  "typeName": "Person"
}
```

#### 2. search_schemas
Search for schema types by keyword.

```json
{
  "query": "article",
  "limit": 10
}
```

#### 3. get_type_hierarchy
Get the inheritance hierarchy for a type.

```json
{
  "typeName": "NewsArticle"
}
```

#### 4. get_type_properties
Get all properties available for a type.

```json
{
  "typeName": "Organization",
  "includeInherited": true
}
```

#### 5. generate_example
Generate an example JSON-LD for a type.

```json
{
  "typeName": "Recipe",
  "properties": {
    "name": "Chocolate Chip Cookies",
    "prepTime": "PT20M"
  }
}
```

## Development

```bash
# Run TypeScript compiler in watch mode
npm run dev

# Run tests
npm test

# Build for production
npm run build
```

## How It Works

The server downloads and caches the complete schema.org vocabulary in JSON-LD format. It then provides various tools to:

1. Query type definitions and their properties
2. Navigate the type hierarchy
3. Generate valid JSON-LD examples
4. Search through the entire vocabulary

The data is fetched from the official schema.org JSON-LD file and indexed in memory for fast access.

## Examples

### Finding Types for a Website

```
User: "What schema types should I use for a blog post?"

Assistant uses: search_schemas with query "blog"
Then: get_type_hierarchy for "BlogPosting"
Finally: generate_example for "BlogPosting"
```

### Understanding Type Properties

```
User: "What properties can I use for a Product?"

Assistant uses: get_type_properties for "Product" with includeInherited: true
```

## Contributing

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

## License

MIT License - see LICENSE file for details.
npm package: @iflow-mcp/tiagodanin-android-debug-bridge-mcp
Description: MCP plugin to control Android devices via ADB for automation, testing, and agent integration
Latest version: 1.0.2

# Android Debug Bridge MCP

MCP plugin to control Android devices via ADB for automation, testing, and agent integration.

## Features

This MCP server provides tools to:

- **Test Management**: Create test folders for organizing automation tests
- **App Control**: List installed apps by name pattern and open apps by package name
- **Screen Capture**: Take screenshots and save them to organized test folders
- **UI Analysis**: Capture UI hierarchy dumps for element inspection
- **Input Simulation**: 
  - Send key events (BACK, HOME, ENTER, DELETE)
  - Tap at specific coordinates
  - Input text into active fields
  - Scroll in any direction (up, down, left, right)

## Installation

Install the package globally via npm:

```bash
npm install -g android-debug-bridge-mcp
```

## Setup for Different AI Clients

### Claude Code (CLI)

Add to your MCP configuration in `~/.claude/mcp.json`:

```json
{
  "mcpServers": {
    "android-debug-bridge": {
      "command": "npx",
      "args": ["android-debug-bridge-mcp"]
    }
  }
}
```

or 

```bash
claude mcp add --scope project android-debug-bridge-mcp -- npx android-debug-bridge-mcp
```

### Cursor

Add to your MCP configuration in Cursor settings:

1. Open Cursor Settings
2. Navigate to Extensions → MCP
3. Add a new server with:
   - **Name**: `android-debug-bridge`
   - **Command**: `npx`
   - **Args**: `["android-debug-bridge-mcp"]`

### Claude Desktop

Add to your MCP configuration file:

**Windows**: `%APPDATA%\Claude\claude_desktop_config.json`
**macOS**: `~/Library/Application Support/Claude/claude_desktop_config.json`
**Linux**: `~/.config/Claude/claude_desktop_config.json`

```json
{
  "mcpServers": {
    "android-debug-bridge": {
      "command": "npx",
      "args": ["android-debug-bridge-mcp"]
    }
  }
}
```

## Prerequisites

- Android Debug Bridge (ADB) must be installed and available in your PATH
- Android device with USB debugging enabled, or Android emulator running
- Device must be connected and authorized for debugging

## Usage

Once configured, you can interact with Android devices through your AI client by asking questions like:

- "Create a test folder called 'login_test'"
- "List all apps with 'chrome' in the name"
- "Open the app com.android.chrome"
- "Take a screenshot and save it as step '001_homepage'"
- "Capture the current UI hierarchy in my app"
- ...

## License

MIT