open-index/open-npm huggingface dataset:
npm package: @mseep/scrapybara-mcp
Description: MCP server for Scrapybara
Author: Scrapybara
Latest version: 0.1.0

<div id="toc" align="center">
  <ul style="list-style: none">
    <summary>
      <h1><img src="images/wow.gif" alt="Scrapybara" width="24"> Scrapybara MCP <img src="images/wow.gif" alt="Scrapybara" width="24"></h1>
    </summary>
  </ul>
</div>

<p align="center">
  <a href="https://github.com/scrapybara/scrapybara-playground/blob/main/license"><img alt="MIT License" src="https://img.shields.io/badge/license-MIT-blue" /></a>
  <a href="https://discord.gg/s4bPUVFXqA"><img alt="Discord" src="https://img.shields.io/badge/Discord-Join%20the%20community-6D1CCF.svg?logo=discord" /></a>
  <a href="https://x.com/scrapybara"><img alt="X" src="https://img.shields.io/badge/Twitter-Follow%20us-6D1CCF.svg?logo=X" /></a>

A Model Context Protocol server for [Scrapybara](https://scrapybara.com). This server enables MCP clients such as [Claude Desktop](https://claude.ai/download), [Cursor](https://www.cursor.com/), and [Windsurf](https://codeium.com/windsurf) to interact with virtual Ubuntu desktops and take actions such as browsing the web, running code, and more.

## Prerequisites

- Node.js 18+
- pnpm
- Scrapybara API key (get one at [scrapybara.com](https://scrapybara.com))

## Installation

1. Clone the repository:

```bash
git clone https://github.com/scrapybara/scrapybara-mcp.git
cd scrapybara-mcp
```

2. Install dependencies:

```bash
pnpm install
```

3. Build the project:

```bash
pnpm build
```

4. Add the following to your MCP client config:

```json
{
  "mcpServers": {
    "scrapybara-mcp": {
      "command": "node",
      "args": ["path/to/scrapybara-mcp/dist/index.js"],
      "env": {
        "SCRAPYBARA_API_KEY": "<YOUR_SCRAPYBARA_API_KEY>",
        "ACT_MODEL": "<YOUR_ACT_MODEL>", // "anthropic" or "openai"
        "AUTH_STATE_ID": "<YOUR_AUTH_STATE_ID>" // Optional, for authenticating the browser
      }
    }
  }
}
```

5. Restart your MCP client and you're good to go!

## Tools

- **start_instance** - Start a Scrapybara Ubuntu instance. Use it as a desktop sandbox to access the web or run code. Always present the stream URL to the user afterwards so they can watch the instance in real time.
- **get_instances** - Get all running Scrapybara instances.
- **stop_instance** - Stop a running Scrapybara instance.
- **bash** - Run a bash command in a Scrapybara instance.
- **act** - Take action on a Scrapybara instance through an agent. The agent can control the instance with mouse/keyboard and bash commands.

## Contributing

Scrapybara MCP is a community-driven project. Whether you're submitting an idea, fixing a typo, adding a new tool, or improving an existing one, your contributions are greatly appreciated!

Before contributing, read through the existing issues and pull requests to see if someone else is already working on something similar. That way you can avoid duplicating efforts.

If there are more tools or features you'd like to see, feel free to suggest them on the [issues page](https://github.com/scrapybara/scrapybara-mcp/issues).
npm package: @mseep/server-branch-thinking
Description: MCP server for managing branching thoughts with insights and cross-references
Latest version: 0.1.0

# Branch Thinking

An MCP server that implements branch-based thought navigation, with support for:
- Multiple branches of thought
- Branch navigation (list, focus, history)
- Cross-references between related thoughts
- Insight generation from key points
- Branch priority tracking

This is based on the `sequential-thinking` tool available here:
https://github.com/modelcontextprotocol/servers/tree/main/src/sequentialthinking

## Features

- **Branch Management**: Create and navigate between different lines of thought
- **Cross References**: Link related thoughts across branches with typed relationships
- **Insights**: Automatically generate insights from key points in thoughts
- **Priority Tracking**: Track branch priorities based on confidence and connections

## Commands

- `list`: Show all branches with their current status
- `focus [branchId]`: Switch focus to a specific branch
- `history [branchId?]`: Show the history of thoughts in a branch

## Installation
Place this project in your custom MCP tool directory.

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

Add to your `claude_desktop_config.json`:
```json
"branch-thinking": {
  "command": "node",
  "args": [
    "/your-custom-mcp-dir-here/branch-thinking/dist/index.js"
  ]
}
```

## Tips
Claude often will not use tools unless explicitly prompted to do so.

If you want to use this tool without being prompted, add to either your Claude Profile Settings (or a system prompt) something like so:


_If I ask you to "think step by step," "think before you respond," or "use chain of thought," that means use the branch-thinking tool. Don't hesitate to use the branch-thinking tool on your own if you think your response would benefit from multiple steps._

## Credits
I can't pretend that I wrote most of this code. Most of it was generated by Claude. The concept was my own, and so were testing, fixes, and implementation.
npm package: @mseep/server-calcom-calendar
Description: MCP server for Cal.com Calendar API integration
Author: Anthropic, PBC
Latest version: 0.6.2

# Cal.com Calendar MCP Server

An MCP server implementation that integrates with Cal.com Calendar API, providing appointment scheduling capabilities.

## Features

- **Add Appointments**: Schedule new calendar appointments with attendee details
- **Update Appointments**: Modify existing appointment details such as time and notes
- **Delete Appointments**: Cancel and remove existing appointments
- **List Appointments**: View scheduled appointments for specific date ranges

## Tools

- **calcom_add_appointment**
  - Create new calendar appointments
  - Inputs:
    - `eventTypeId` (number): The Cal.com event type ID
    - `startTime` (string): Start time in ISO format (YYYY-MM-DDTHH:mm:ss.sssZ)
    - `endTime` (string): End time in ISO format (YYYY-MM-DDTHH:mm:ss.sssZ)
    - `name` (string): Attendee's name
    - `email` (string): Attendee's email
    - `notes` (string, optional): Additional notes for the appointment

- **calcom_update_appointment**
  - Update existing calendar appointments
  - Inputs:
    - `bookingId` (number): The Cal.com booking ID to update
    - `startTime` (string, optional): New start time in ISO format
    - `endTime` (string, optional): New end time in ISO format
    - `notes` (string, optional): New notes for the appointment

- **calcom_delete_appointment**
  - Delete existing calendar appointments
  - Inputs:
    - `bookingId` (number): The Cal.com booking ID to delete
    - `reason` (string, optional): Reason for cancellation

- **calcom_list_appointments**
  - List calendar appointments in a date range
  - Inputs:
    - `startDate` (string): Start date in YYYY-MM-DD format
    - `endDate` (string): End date in YYYY-MM-DD format


## Configuration

### Getting an API Key
1. Sign up for a [Cal.com account](https://cal.com)
2. Navigate to Settings > Developer > API Keys
3. Generate a new API key with appropriate permissions

### Usage with Claude Desktop
Add this to your `claude_desktop_config.json`:

### Docker

```json
{
  "mcpServers": {
    "calcom-calendar": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "-e",
        "CALCOM_API_KEY",
        "mcp/calcom-calendar"
      ],
      "env": {
        "CALCOM_API_KEY": "YOUR_API_KEY_HERE"
      }
    }
  }
}
```

### NPX

```json
{
  "mcpServers": {
    "calcom-calendar": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-calcom-calendar"
      ],
      "env": {
        "CALCOM_API_KEY": "YOUR_API_KEY_HERE"
      }
    }
  }
}
```


## Build

Docker build:

```bash
docker build -t mcp/calcom-calendar:latest -f Dockerfile .
```

## 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.
npm package: @mseep/server-cmd
Description: MCP server for executing CMD and SSH commands
Author: Phiality
Latest version: 1.0.0

# CMD MCP Server

[![smithery badge](https://smithery.ai/badge/server-cmd)](https://smithery.ai/server/server-cmd)
![npm downloads](https://img.shields.io/npm/dt/server-cmd)
A Model Context Protocol (MCP) server implementation for executing CMD commands on both Windows and Linux, as well as allowing SSH connections. This server allows you to integrate command-line operations with MCP-compatible applications.

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

## Features

- Execute CMD commands through MCP
- TypeScript implementation
- Built on the official MCP SDK
- Cross-platform compatibility

## Installation

### Installing via Smithery

To install CMD Server for Claude Desktop automatically via [Smithery](https://smithery.ai/server/server-cmd):

```bash
npx -y @smithery/cli install server-cmd --client claude
```

### Manual Installation
```bash
npm install server-cmd
```

## Prerequisites

- Node.js (v16 or higher recommended)
- npm or yarn package manager

## Usage

```typescript
import { MCPCmdServer } from 'server-cmd';

// Initialize the server
const server = new MCPCmdServer();

// Start the server
server.start();
```

## Configuration

The server can be configured through environment variables or a configuration object:

```typescript
const config = {
  // Add your configuration options here
};

const server = new MCPCmdServer(config);
```

## Development

To set up the development environment:

1. Clone the repository:
```bash
git clone https://github.com/PhialsBasement/CMD-MCP-Server.git
cd CMD-MCP-Server
```

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

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

## Scripts

- `npm run build` - Compile TypeScript to JavaScript
- `npm run prepare` - Prepare the package for publishing

## Dependencies

- `@modelcontextprotocol/sdk`: ^1.0.1
- `glob`: ^10.3.10
- `zod-to-json-schema`: ^3.23.5

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

## Security

Please note that executing command-line operations can be potentially dangerous. Make sure to implement proper security measures and input validation when using this server in production environments.

## Support

For issues and feature requests, please use the [GitHub issue tracker](https://github.com/PhialsBasement/CMD-MCP-Server/issues).
npm package: @mseep/server-curl
Description: MCP server for making HTTP requests using a curl-like interface
Author: Michael Latman
Latest version: 0.1.0

# @mcp-get-community/server-curl

An MCP server that allows LLMs to make HTTP requests to any URL using a curl-like interface.

## Features

- Make HTTP requests to any URL
- Support for all common HTTP methods (GET, POST, PUT, DELETE, PATCH, HEAD, OPTIONS)
- Customizable headers and request body
- Configurable timeout
- Full response information including status, headers, and body

## Installation

```bash
npx @michaellatman/mcp-get@latest install @mcp-get-community/server-curl
```

## Usage

```json
{
  "mcpServers": {
    "@mcp-get-community/server-curl": {
      "runtime": "node",
      "command": "npx",
      "args": [
        "-y",
        "@mcp-get-community/server-curl"
      ]
    }
  }
}
```

The server provides a single tool called `curl` that accepts the following parameters:

- `url` (required): The URL to make the request to
- `method` (optional): HTTP method to use (default: 'GET')
- `headers` (optional): Object containing HTTP headers
- `body` (optional): Request body for POST/PUT/PATCH requests
- `timeout` (optional): Request timeout in milliseconds (default: 30000, max: 300000)

### Example Request

```json
{
  "url": "https://api.example.com/data",
  "method": "POST",
  "headers": {
    "Content-Type": "application/json",
    "Authorization": "Bearer token123"
  },
  "body": "{\"key\": \"value\"}",
  "timeout": 5000
}
```

### Example Response

```json
{
  "status": 200,
  "statusText": "OK",
  "headers": {
    "content-type": "application/json",
    "server": "nginx"
  },
  "body": "{\"result\": \"success\"}"
}
```

## Development

```bash
# Install dependencies
npm install

# Build the project
npm run build

# Run in development mode
npm run dev
```

## License

MIT
npm package: @mseep/server-framer-plugin
Description: MCP server for creating and managing Framer plugins with web3 capabilities
Latest version: 0.1.0

# Framer Plugin MCP Server

A Model Context Protocol (MCP) server that enables creation and management of Framer plugins with web3 capabilities. This server provides tools for creating, building, and managing Framer plugins with integrated web3 features like wallet connections, contract interactions, and NFT displays.

## Features

- Create new Framer plugins with web3 capabilities
- Build plugins for production
- Integrated web3 features:
  - Wallet Connect integration
  - Smart contract interactions
  - NFT display components

## Requirements

- Node.js 16 or higher
- NPM or Yarn
- Framer desktop app for testing plugins

## Installation

1. Clone this repository:
```bash
git clone https://github.com/sheshiyer/framer-plugin-mcp.git
cd framer-plugin-mcp
```

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

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

## Configuration

Add the server to your MCP settings file:

For Claude Desktop App (`~/Library/Application Support/Claude/claude_desktop_config.json`):
```json
{
  "mcpServers": {
    "framer-plugin": {
      "command": "node",
      "args": ["/path/to/framer-plugin-mcp/build/index.js"]
    }
  }
}
```

For Cursor/Claude Dev (`~/Library/Application Support/Cursor/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json`):
```json
{
  "mcpServers": {
    "framer-plugin": {
      "command": "node",
      "args": ["/path/to/framer-plugin-mcp/build/index.js"]
    }
  }
}
```

## Usage

Once configured, the server provides the following tools:

### create_plugin
Creates a new Framer plugin project with web3 capabilities.

Parameters:
- name: Plugin name
- description: Plugin description
- outputPath: Output directory path
- web3Features: Array of features to include (wallet-connect, contract-interaction, nft-display)

Example:
```json
{
  "name": "my-web3-plugin",
  "description": "A Framer plugin with web3 features",
  "outputPath": "./plugins/my-web3-plugin",
  "web3Features": ["wallet-connect", "nft-display"]
}
```

### build_plugin
Builds a Framer plugin project for production.

Parameters:
- pluginPath: Path to plugin directory

Example:
```json
{
  "pluginPath": "./plugins/my-web3-plugin"
}
```

## Contributing

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

## License

MIT License - see LICENSE file for details
npm package: @mseep/server-github-projects
Description: MCP server for GitHub Projects V2 API
Latest version: 0.1.0

# MCP Server for GitHub Projects

An MCP (Model Context Protocol) server for interacting with the GitHub Projects V2 API.

## Description

This MCP server allows language models to interact with GitHub Projects V2 through a set of tools that provide create, read, update, and delete (CRUD) operations for projects and their associated resources such as items, fields, and views.

## Features

### Project Operations
- List projects for a user or organization
- Get details of a specific project
- Create a new project
- Update an existing project
- Delete a project

### Item Operations
- List items in a project
- Add an issue or pull request to a project
- Create a draft item
- Remove an item from a project
- Get details of a specific item

### Field Operations
- List fields in a project
- Create a new custom field
- Update a field value for an item
- Delete a custom field

### View Operations
- List views of a project
- Create a new view
- Update an existing view
- Delete a view

## Prerequisites

- Node.js (version 18 or higher)
- GitHub personal access token with `repo` and `project` scopes

## Installation

```bash
npm install @devassistantai/server-github-projects
```

## Configuration

Set the `GITHUB_PERSONAL_ACCESS_TOKEN` environment variable with your GitHub personal access token:

```bash
export GITHUB_PERSONAL_ACCESS_TOKEN=your_token_here
```

## Usage

### As a module

```javascript
import { startServer } from '@devassistantai/server-github-projects';

startServer();
```

### As an executable

```bash
npx mcp-server-github-projects
```

## Example Usage

Here's an example of how to use this server with an MCP-based AI platform:

```
# List projects for a user
mcp__list_projects(owner="octocat", type="user")

# Create a new project
mcp__create_project(owner="my-org", title="My New Project", type="organization", description="A project to manage tasks")

# Add an item to the project
mcp__add_project_item(project_id="PVT_kwHOA...", content_id="I_kwDOA...")

# Create a single select custom field
mcp__create_project_field(project_id="PVT_kwHOA...", name="Status", dataType="SINGLE_SELECT", options=["In progress", "Completed", "Blocked"])

# Update a field value for an item
mcp__update_project_field_value(project_id="PVT_kwHOA...", item_id="PVTI_lADOA...", field_id="PVTF_lADOA...", value={optionId: "PVTFO_lADOA..."})
```

## Limitations

- This server uses the GitHub GraphQL API for Projects V2, which requires a personal access token with appropriate scopes.
- Some advanced view customization operations, such as complex filter configuration, may not be available in this version.

## Additional Resources

- [GitHub Projects V2 Documentation](https://docs.github.com/en/issues/planning-and-tracking-with-projects)
- [GitHub GraphQL API Documentation](https://docs.github.com/en/graphql)
- [MCP (Model Context Protocol) Documentation](https://modelcontextprotocol.ai)

## License

MIT
npm package: @mseep/server-hyperliquid
Description: MCP server for Hyperliquid
Author: mektigboy
Latest version: 0.0.1

# Hyperliquid MCP Server

An MCP server implementation that integrates the Hyperliquid SDK.

## Tools

- **get_all_mids**

  - Retrieve mid prices for all coins on Hyperliquid
  - No required inputs

- **get_candle_snapshot**

  - Get historical candlestick data for any token
  - Inputs:
    - `coin` (string): Token symbol
    - `interval` (string): Time interval (e.g., '15m', '1h')
    - `startTime` (number): Start time in milliseconds since epoch
    - `endTime` (number, optional): End time in milliseconds since epoch

- **get_l2_book**
  - Access the L2 order book for any token
  - Inputs:
    - `symbol` (string): Token symbol

### Usage with Claude Desktop

Add this to your `claude_desktop_config.json`:

### NPX

```json
{
  "mcpServers": {
    "brave-search": {
      "command": "npx",
      "args": ["-y", "@mektigboy/server-hyperliquid"]
    }
  }
}
```

## 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.
npm package: @mseep/server-juliadoc
Description: MCP server for Julia documentation and source code access
Author: Jonathan Fischer
Latest version: 1.0.3

# Julia Documentation MCP Server 
![](https://badge.mcpx.dev?type=server 'MCP Server') 

An MCP server that efficiently serves context to Claude Desktop about Julia documentation and source code.

<a href="https://glama.ai/mcp/servers/7xy80o4wdp"><img width="380" height="200" src="https://glama.ai/mcp/servers/7xy80o4wdp/badge" alt="Julia Documentation Server MCP server" /></a>

## Features

- Get documentation for Julia packages, modules, types, functions, and methods
- View source code for Julia functions, types, and methods
- Built-in caching with 5-minute TTL
- Proper error handling for Julia-specific errors

## Tools

### `get-doc`
Gets Julia documentation for a package, module, type, function, or method.
- Parameter: `path` (string) - Path to Julia object (e.g., 'Base.sort', 'AbstractArray')

### `get-source`
Gets Julia source code for a function, type, or method.
- Parameter: `path` (string) - Path to Julia object (e.g., 'Base.sort', 'AbstractArray')

## Requirements

- Node.js 16 or higher
- Julia 1.9 or higher installed and accessible in PATH
- Claude Desktop

## Configuration

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

```json
{
  "mcpServers": {
    "juliadoc": {
      "command": "npx",
      "args": [
        "-y",
        "@jonathanfischer97/server-juliadoc"
      ],
      "env": {
        "JULIA_PROJECT": "/path/to/your/julia/project"
      }
    }
  }
}
```

The server will use:
- Your specified Julia project if `JULIA_PROJECT` is set in the config
- The default global Julia environment if no project is specified
- Your system's default Julia installation (must be accessible in PATH)

## Development

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

# Install dependencies
npm install

# Build
npm run build

# Start server locally
npm start
```

## Contributing

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

Credit goes to [mrjoshuak/godoc-mcp](https://github.com/mrjoshuak/godoc-mcp) for inspiring this project

## License

MIT License - see LICENSE file for details
npm package: @mseep/server-koboldai
Description: MCP server for KoboldAI API integration
Author: Phiality
Latest version: 1.0.0

# Kobold MCP Server

A Model Context Protocol (MCP) server implementation for interfacing with KoboldAI. This server enables integration between KoboldAI's text generation capabilities and MCP-compatible applications.

## Features

- Text generation with KoboldAI
- Chat completion with persistent memory
- OpenAI-compatible API endpoints
- Stable Diffusion integration
- Built on the official MCP SDK
- TypeScript implementation

<a href="https://glama.ai/mcp/servers/a2xd4hoij7"><img width="380" height="200" src="https://glama.ai/mcp/servers/a2xd4hoij7/badge" alt="Kobold Server MCP server" /></a>

## Installation

```bash
npm install kobold-mcp-server
```

## Prerequisites

- Node.js (v16 or higher)
- npm or yarn package manager
- Running KoboldAI instance

## Usage

```typescript
import { KoboldMCPServer } from 'kobold-mcp-server';

// Initialize the server
const server = new KoboldMCPServer();

// Start the server
server.start();
```

## Configuration

The server can be configured through environment variables or a configuration object:

```typescript
const config = {
  apiUrl: 'http://localhost:5001' // KoboldAI API endpoint
};
const server = new KoboldMCPServer(config);
```

## Supported APIs

- Core KoboldAI API (text generation, model info)
- Chat completion with conversation memory
- Text completion (OpenAI-compatible)
- Stable Diffusion integration (txt2img, img2img)
- Audio transcription and text-to-speech
- Web search capabilities

## Development

1. Clone the repository:
```bash
git clone https://github.com/yourusername/kobold-mcp-server.git
cd kobold-mcp-server
```

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

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

## Dependencies

- `@modelcontextprotocol/sdk`: ^1.0.1
- `node-fetch`: ^2.6.1
- `zod`: ^3.20.0
- `zod-to-json-schema`: ^3.23.5

## Contributing

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

## License

MIT License - see LICENSE file for details.

## Support

For issues and feature requests, please use the GitHub issue tracker.
npm package: @mseep/server-systemd-coredump
Description: A Model Context Protocol (MCP) server for systemd-coredump
Author: signal-slot
Latest version: 0.1.1

# @taskjp/server-systemd-coredump

A Model Context Protocol (MCP) server for interacting with systemd-coredump functionality. This enables MCP-capable applications to access, manage, and analyze system core dumps.

## Prerequisites

- Node.js 18+ and npm
- systemd-coredump must be installed and configured on the system
- `coredumpctl` command-line utility must be available
- For stack trace functionality: `gdb` must be installed

## Installation

### Global Installation (recommended for CLI usage)

```bash
npm install -g @taskjp/server-systemd-coredump
```

### Local Installation (for use in a project)

```bash
npm install @taskjp/server-systemd-coredump
```

## Usage

### As an MCP Server

1. Add the server to your MCP configuration file:

```json
"systemd-coredump": {
  "command": "node",
  "args": ["node_modules/@taskjp/server-systemd-coredump/build/index.js"],
  "disabled": false,
  "autoApprove": []
}
```

If installed globally:

```json
"systemd-coredump": {
  "command": "systemd-coredump-server",
  "args": [],
  "disabled": false,
  "autoApprove": []
}
```

2. Connect to it using any MCP client or language model.

### Testing with MCP Inspector

Use the MCP Inspector to test the server directly:

```bash
npx @modelcontextprotocol/inspector node_modules/@taskjp/server-systemd-coredump/build/index.js
```

Or if installed globally:

```bash
npx @modelcontextprotocol/inspector systemd-coredump-server
```

## Available Tools

The server provides the following tools:

1. **list_coredumps**: List available coredumps in the system
   - Optional parameter: `onlyPresent` (boolean) - When true, only returns coredumps with COREFILE=="present"

2. **get_coredump_info**: Get detailed information about a specific coredump
   - Required parameter: `id` (string) - ID of the coredump

3. **extract_coredump**: Extract a coredump to a file
   - Required parameters: 
     - `id` (string) - ID of the coredump
     - `outputPath` (string) - Path where to save the extracted coredump

4. **get_coredump_config**: Get the current core dump configuration of the system

5. **set_coredump_enabled**: Enable or disable core dump generation
   - Required parameter: `enabled` (boolean) - Whether to enable or disable core dumps

6. **get_stacktrace**: Get stack trace from a coredump using GDB
   - Required parameter: `id` (string) - ID of the coredump

## Available Resources

The server exposes two types of resources:

1. **Coredump Information**
   - URI format: `coredump:///<id>`
   - Returns JSON with detailed coredump information

2. **Stack Traces**
   - URI format: `stacktrace:///<id>`
   - Returns a formatted stack trace from the coredump

Where `<id>` is the unique identifier for a coredump in the format: `<timestamp>-<pid>`.

## Note on Permissions

Some operations may require elevated privileges, especially when extracting or removing coredumps. Ensure the user running the MCP server has appropriate permissions to access system coredumps.

## License

MIT
npm package: @mseep/server-veri5ight
Description: Simplified MCP server for ENS DAO operations
Latest version: 0.1.0

# 🔍 Veri5ight

> Your friendly neighborhood Ethereum node whisperer! A Model Context Protocol (MCP) server that helps Claude chat with Ethereum nodes.

## 🌟 What's This All About?

Veri5ight is like a universal translator between Claude and Ethereum nodes. It helps Claude:

- 💰 Check ENS token balances
- 🔎 Peek at smart contract code
- 🕵️‍♂️ Decode mysterious transactions

## 🚀 Quick Start

```bash
# Clone this bad boy
git clone https://github.com/5ajaki/veri5ight.git

# Install the goodies
npm install

# Build it!
npm run build
```

## ⚙️ Configuration

1. Copy `.env.example` to `.env`:

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

2. Add your Ethereum node URL:

```env
ETH_NODE_URL="http://your.awesome.node:8545"
```

3. Configure Claude Desktop:

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

## 🎮 Available Tools

### 🏦 ethereum/getENSBalance

```
Claude, what's vitalik.eth's ENS balance?
```

### 📝 ethereum/getContractCode

```
Claude, show me the contract code for uniswap.eth
```

### 🔍 ethereum/decodeTransaction

```
Claude, what's happening in tx 0x1234...?
```

## 🛠️ Development

```bash
# Watch mode for the cool kids
npm run dev

# Build for production
npm run build
```

## 🤝 Contributing

Got ideas? Found a bug? PRs are welcome! Just:

1. Fork it
2. Branch it
3. Code it
4. PR it

## 📜 License

MIT - Go wild! See [LICENSE](LICENSE) for the boring legal stuff.

## 🙏 Props

- Built with ❤️ by the Veri5ight team
- Powered by Claude's big brain
- Standing on the shoulders of Ethereum giants

## 🆘 Need Help?

- 🐛 Found a bug? Open an issue!
- 🤔 Questions? Start a discussion!
- 🎉 Cool feature idea? Let's hear it!

Remember: Veri5ight is like a Swiss Army knife for Ethereum data - just don't try to open bottles with it! 🍾
npm package: @mseep/server-win-cli
Description: MCP server for Windows CLI interactions
Author: Simon Benedict
Latest version: 0.1.8

# Super Windows CLI MCP Server

An enhanced fork of the Windows CLI MCP Server with unrestricted system access capabilities.

## Enhancements

- Full system access through SYSTEM service installation
- Unrestricted command execution
- Network-level access controls
- Unlimited process capabilities
- Auto-recovery and fault tolerance
- PowerShell telemetry disabled

## Security Notice

This version removes application-level restrictions in favor of network-level security. It is designed for use in trusted environments where full system access is required.

## Features

- Complete access to Windows shell environments (PowerShell, CMD, Git Bash)
- No command or argument restrictions
- Full file system access
- SYSTEM-level service installation
- Automatic service recovery
- Network binding controls
- Process reuse for performance
- Extended timeouts for long-running operations

## Installation

1. Build the project:
```bash
npm install
npm run build
```

2. Copy the built files to your Windows machine

3. Run the installation script as administrator:
```powershell
.\install-service.ps1
```

## Configuration

The server is configured for maximum capability with these key features:

- No command restrictions
- Full filesystem access
- Disabled injection protection
- Unlimited process resources
- Network-level access control
- SYSTEM-level privileges

See `config.json` for the complete configuration.

## Service Management

### Installation
```powershell
.\install-service.ps1
```

### Removal
```powershell
.\uninstall-service.ps1
```

## Network Security

While application-level restrictions are removed, the following network-level protections are in place:

- Localhost binding by default
- Configurable allowed IP ranges
- Local network restriction
- Optional VPN integration

## License

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

## Acknowledgments

Based on the original [win-cli-mcp-server](https://github.com/SimonB97/win-cli-mcp-server) by SimonB97.
npm package: @mseep/shadow-cljs-mcp
Description: A Model Context Protocol server for monitoring shadow-cljs builds
Author: ModelContextProtocol
Latest version: 0.1.3

# shadow-cljs-mcp

[![npm version](https://badge.fury.io/js/shadow-cljs-mcp.svg)](https://badge.fury.io/js/shadow-cljs-mcp)

A Model Context Protocol (MCP) server that monitors shadow-cljs builds and provides real-time build status updates.

## Installation

Add the following to your Cline/Cursor/Claude whatever settings:
```json
{
  "mcpServers": {
    "shadow-cljs-mcp": {
      "command": "npx",
      "args": [
        "shadow-cljs-mcp"
      ],
      "disabled": false,
      "autoApprove": [],
      "timeout": 60
    }
  }
}
```
With optional server location
```json
{
  "mcpServers": {
    "shadow-cljs-mcp": {
      "command": "npx",
      "args": [
        "shadow-cljs-mcp",
        "--host",
        "localhost",
        "--port",
        "9630"
      ],
      "disabled": false,
      "autoApprove": [],
      "timeout": 60
    }
  }
}
```

The `--host` and `--port` arguments are optional. If not provided, the server will default to connecting to `localhost:9630`.

## Overview

This MCP server connects to a running shadow-cljs instance and tracks build progress, failures, and completions. It provides an MCP tool that LLMs can use to verify build status after making changes to ClojureScript files.

## LLM Integration

### Adding to Your LLM Notes

Add the following to your LLM's notes file (e.g., CLAUDE.md, cursorrules.md):

```markdown
After any edits to ClojureScript files, use the shadow-cljs-mcp server's get_last_build_status tool to verify the build succeeded:

<use_mcp_tool>
<server_name>shadow-cljs-mcp</server_name>
<tool_name>get_last_build_status</tool_name>
<arguments>
{}
</arguments>
</use_mcp_tool>

This will show:
- Build status (completed/failed)
- Which files were compiled
- Any errors or warnings
- Build duration and metrics
```

## Example Tool Response

Successful build:
```json
{
  "status": "completed",
  "resources": 317,
  "compiled": 1,
  "warnings": 0,
  "duration": 0.609,
  "compiledFiles": [
    "path/to/your/file.cljs (505ms)"
  ]
}
```

Failed build:
```json
{
  "status": "failed",
  "message": "Build failed",
  "details": {
    // Error information
  }
}
```

## Usage Notes

- LLMs should call get_last_build_status after each ClojureScript file edit
- Compilation errors will be shown in detail for easy debugging
- Successful builds show which files were compiled and how long they took
- Make sure shadow-cljs is running before starting this server

## Requirements
- Running shadow-cljs instance (defaults to localhost:9630 if not configured otherwise)
npm package: @mseep/simple-memory-extension-mcp-server
Description: An MCP server providing a persistent key-value memory store with semantic search for your agents
Author: gmacev
Latest version: 1.0.0

# Simple Memory Extension MCP Server

An MCP server to extend the context window / memory of agents. Useful when coding big features or vibe coding and need to store/recall progress, key moments or changes or anything worth remembering. Simply ask the agent to store memories and recall whenever you need or ask the agent to fully manage its memory (through cursor rules for example) however it sees fit.

## Usage

### Starting the Server

```bash
npm install
npm start
```

### Available Tools

#### Context Item Management
- `store_context_item` - Store a value with key in namespace
- `retrieve_context_item_by_key` - Get value by key
- `delete_context_item` - Delete key-value pair

#### Namespace Management
- `create_namespace` - Create new namespace
- `delete_namespace` - Delete namespace and all contents
- `list_namespaces` - List all namespaces
- `list_context_item_keys` - List keys in a namespace

#### Semantic Search
- `retrieve_context_items_by_semantic_search` - Find items by meaning

### Semantic Search Implementation

1. Query converted to vector using E5 model
2. Text automatically split into chunks for better matching
3. Cosine similarity calculated between query and stored chunks
4. Results filtered by threshold and sorted by similarity
5. Top matches returned with full item values

## Development

```bash
# Dev server
npm run dev

# Format code
npm run format
```

## .env

```
# Path to SQLite database file
DB_PATH=./data/context.db

PORT=3000

# Use HTTP SSE or Stdio
USE_HTTP_SSE=true

# Logging Configuration: debug, info, warn, error
LOG_LEVEL=info
```

## Semantic Search

This project includes semantic search capabilities using the E5 embedding model from Hugging Face. This allows you to find context items based on their meaning rather than just exact key matches.

### Setup

The semantic search feature requires Python dependencies, but these *should be* automatically installed when you run: `npm run start`

### Embedding Model

We use the [intfloat/multilingual-e5-large-instruct](https://huggingface.co/intfloat/multilingual-e5-large-instruct)


### Notes

Developed mostly while vibe coding, so don't expect much :D. But it works, and I found it helpful so w/e. Feel free to contribute or suggest improvements.
npm package: @mseep/simple-nodejs-mcp-client
Description: A simple CLI tool to interact with the Model Context Protocol (MCP) and Claude AI.
Author: sawa-zen
Latest version: 0.1.0

# Simple Nodejs MCP Client

This is a study repository for implementing a Model Context Protocol (MCP) client. It features a simple interactive MCP client implemented in Node.js.

![screenshot](./screenshot.png)

## Installation

```bash
npm install
```

## Configuration

1. Copy the example configuration file:
```bash
cp config.example.json config.json
```

2. Edit `config.json` and update the configuration values with your own settings:
- `claudeApiKey`: Your Claude API key
- `systemPrompt`: The system prompt for the anthorpic client
- `mcpServers`: Configuration for MCP servers (if needed)

## Usage

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

2. Start the client:
```bash
npm run start
```

## License

See [LICENSE](./LICENSE) file for details.
npm package: @mseep/sms-mcp-server
Description: A Model Context Protocol (MCP) server that enables Claude and other AI assistants to send SMS and MMS messages using Twilio.
Author: Yiyang Li
Latest version: 2025.2.24

# Twilio MCP Server

A Model Context Protocol (MCP) server that enables Claude and other AI assistants to send SMS and MMS messages using Twilio.

## Demo

![Demo](./assets/demo.gif)

## Features

- Send SMS messages 📱
- Pre-built prompts for common messaging scenarios 📝
- Secure handling of Twilio credentials 🔒

## Requirements

- Node.js >= 18
  - If you need to update Node.js, we recommend using `nvm` (Node Version Manager):
    ```bash
    nvm install 18.14.2
    nvm alias default 18.14.2
    ```
  - If you encounter any errors in Claude Desktop, try running the following command in your terminal to verify the installation:
    ```bash
    npx -y @yiyang.1i/sms-mcp-server
    ```

## Configuration

The server requires three environment variables:

- `ACCOUNT_SID`: Your Twilio account SID
- `AUTH_TOKEN`: Your Twilio auth token
- `FROM_NUMBER`: Your Twilio phone number (in E.164 format, e.g., +11234567890)

### Claude Desktop Configuration

To use this server with Claude Desktop, add the following to your configuration file:

**macOS**: `~/Library/Application Support/Claude/claude_desktop_config.json`

**Windows**: `%APPDATA%\Claude\claude_desktop_config.json`

```json
{
  "mcpServers": {
    "twilio": {
      "command": "npx",
      "args": [
        "-y",
        "@yiyang.1i/sms-mcp-server"
      ],
      "env": {
        "ACCOUNT_SID": "your_account_sid",
        "AUTH_TOKEN": "your_auth_token",
        "FROM_NUMBER": "your_twilio_number"
      }
    }
  }
}
```
After that, restart Claude Desktop to reload the configuration. 
If connected, you should see Twilio under the 🔨 menu.

## Example Interactions with Claude

Here are some natural ways to interact with the server through Claude:

1. Simple SMS:
```
Send a text message to the number +11234567890 saying "Don't forget about dinner tonight!"
```

2. Creative SMS:
```
Write a haiku about autumn and send it to my number +11234567890
```

## Important Notes

1. **Phone Number Format**: All phone numbers must be in E.164 format (e.g., +11234567890)
2. **Rate Limits**: Be aware of your Twilio account's rate limits and pricing
3. **Security**: Keep your Twilio credentials secure and never commit them to version control

## Troubleshooting

Common error messages and solutions:

1. "Phone number must be in E.164 format"
   - Make sure the phone number starts with "+" and the country code

2. "Invalid credentials"
   - Double-check your ACCOUNT_SID and AUTH_TOKEN. You can copy them from the [Twilio Console](https://console.twilio.com)

## Contributing

Contributions are welcome! Please read our contributing guidelines before submitting pull requests.

## License

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

## Security

Please do not include any sensitive information (like phone numbers or Twilio credentials) in GitHub issues or pull requests.
npm package: @mseep/sourcify-context-server
Description: A MPC server for sourcify.eth
Author: Yurii Kabannik
Latest version: 0.1.0

# sourcify-context-server MCP Server

A Model Context Protocol server

This is a TypeScript-based MCP server that implements a simple notes system. It demonstrates core MCP concepts by providing:

- Resources representing text notes with URIs and metadata
- Tools for creating new notes
- Prompts for generating summaries of notes

## Features

### Resources
- List and access notes via `note://` URIs
- Each note has a title, content and metadata
- Plain text mime type for simple content access

### Tools
- `create_note` - Create new text notes
  - Takes title and content as required parameters
  - Stores note in server state

### Prompts
- `summarize_notes` - Generate a summary of all stored notes
  - Includes all note contents as embedded resources
  - Returns structured prompt for LLM summarization

## Development

Install dependencies:
```bash
npm install
```

Build the server:
```bash
npm run build
```

For development with auto-rebuild:
```bash
npm run watch
```

## Installation

To use with Claude Desktop, add the server config:

On MacOS: `~/Library/Application Support/Claude/claude_desktop_config.json`
On Windows: `%APPDATA%/Claude/claude_desktop_config.json`

```json
{
  "mcpServers": {
    "sourcify-context-server": {
      "command": "/path/to/sourcify-context-server/build/index.js"
    }
  }
}
```

### Debugging

Since MCP servers communicate over stdio, debugging can be challenging. We recommend using the [MCP Inspector](https://github.com/modelcontextprotocol/inspector), which is available as a package script:

```bash
npm run inspector
```

The Inspector will provide a URL to access debugging tools in your browser.