semvec/pypi-packages huggingface dataset:
iflow-mcp_oraichain_ragflow-mcp 0.1.4
Simple MCP server for RAGFlow
Requires Python: >=3.11

# ragflow-mcp
Simple RAGFlow MCP. Only useful until the RAGFlow team releases the official MCP server

## Installation

We provide two installation methods. Method 2 (using uv) is recommended for faster installation and better dependency management.

### Method 1: Using conda

1. Create a new conda environment:

```bash
conda create -n ragflow_mcp python=3.12
conda activate ragflow_mcp
```

2. Clone the repository:

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

3. Install dependencies:

```bash
pip install -r requirements.txt
```

### Method 2: Using uv (Recommended)

1. Install uv (A fast Python package installer and resolver):

```bash
curl -LsSf https://astral.sh/uv/install.sh | sh
```

2. Clone the repository:

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

3. Create a new virtual environment and activate it:

```bash
uv venv --python 3.12
source .venv/bin/activate  # On Unix/macOS
# Or on Windows:
# .venv\Scripts\activate
```

4. Install dependencies:

```bash
uv pip install -r pyproject.toml
```

# Run MCP Server Inspector for debugging

1. Start the MCP server

2. Start the inspector using the following command:

```bash
# you can choose a different server
SERVER_PORT=9000 npx @modelcontextprotocol/inspector
iflow-mcp_virajsharma2000-mcp-websocket 0.1.0
MCP WebSocket Server with stdio support
Requires Python: >=3.10

# MCP WebSocket Server

This project implements an MCP (Model Context Protocol) server with WebSocket enhancements for real-time data updates. It allows clients to make standard MCP requests while also enabling WebSocket-based subscriptions to receive push notifications when new data becomes available.

## Features
- **MCP Server (Port 8080):** Handles standard MCP requests from clients.
- **WebSocket Server (Port 8765):** Allows clients to subscribe for real-time updates.
- **Push Notifications:** Sends updates to all subscribed clients when new data is available.
- **Async Architecture:** Uses `asyncio` for efficient non-blocking operations.

## Installation
1. Clone this repository:
   ```sh
   git clone https://github.com/your-repo/mcp-websocket-server.git
   cd mcp-websocket-server
   ```
2. Install dependencies:
   ```sh
   pip install websockets mcp-sdk  # Replace with actual MCP SDK package name
   ```

## Usage
### Start the Server
Run the following command to start both the MCP and WebSocket servers:
```sh
python server.py
```

### Connecting via WebSockets
Clients can connect to the WebSocket server (`ws://localhost:8765`) and subscribe to updates by sending:
```json
{"action": "subscribe"}
```

### Sending MCP Requests
MCP clients can send requests to the MCP server at `http://localhost:8080` with a payload like:
```json
{"method": "get_data"}
```
The server will respond with:
```json
{"result": "Here is your data!"}
```

## License
This project is licensed under the MIT License.

## Contributing
Pull requests are welcome! For major changes, please open an issue first to discuss what you’d like to change.

## Contact
For questions or suggestions, reach out via [virajsharma@sharmaviraj.com].

# mcp-websocket
This server implements an MCP (Model Context Protocol) server with WebSocket enhancements for real-time data updates.
mustafatik 0.1.1
A utility library for generating device and user-agent data.
Requires Python: >=3.6

# mustafatik

مكتبة بايثون مساعدة لتوليد بيانات الأجهزة ودمجها مع وكلاء المستخدم (User-Agents).

## التثبيت

```bash
pip install mustafatik
```

## الإصدار 0.0.8 الجديد
في هذا الإصدار، تقوم المكتبة بأخذ الـ `User-Agent` الممرر في الـ `headers` وتضيف إليه تفاصيل الجهاز المولد تلقائياً.

## الاستخدام

```python
from mustafatik import mustafatik

# إنشاء كائن من المكتبة
device_generator = mustafatik()

# تحديث الرؤوس (Headers)
# سيتم أخذ User-Agent من الهيدرز وإضافة بيانات الجهاز إليه
headers = {"User-Agent": "MyCustomApp/1.0"}
updated_headers = device_generator.updateHeaders(headers)

print(updated_headers["User-Agent"])
```

## المطور
مصطفى تليجرام: @PPH9P
flac-cue-split 0.1.2
Split FLAC files into individual tracks based on CUE sheets
Requires Python: >=3.12

# flac-cue-split

Split single-file FLAC albums into individual tracks using CUE sheets.

**Perfect for Plex users**: Plex and other media servers don't support CUE sheets, so albums ripped as a single FLAC file won't display individual tracks. This tool splits them into separate files with proper metadata so Plex can index each track correctly.

## Features

- Recursively searches directories for FLAC + CUE pairs
- Automatic CUE file encoding detection (UTF-8, Latin-1, Shift-JIS, etc.)
- Skips albums that are already split
- Safe dry-run by default - see what would happen before committing
- Prompts before deleting source files
- Preserves CUE files after splitting

## Requirements

- Python 3.12+
- [ffmpeg](https://ffmpeg.org/download.html) installed and in PATH
    - **Ubuntu/Debian**: `sudo apt install ffmpeg`
    - **macOS**: `brew install ffmpeg`
    - **Windows**: Download from [ffmpeg.org](https://ffmpeg.org/download.html) and add to PATH

## Installation

```bash
# Using uv (recommended)
uv tool install flac-cue-split

# Using pipx
pipx install flac-cue-split

# Using pip
pip install flac-cue-split
```

## Usage

```bash
# Dry run - see what would be split
flac-cue-split /path/to/music

# Actually split the files
flac-cue-split /path/to/music --execute

# Split and delete original FLAC files (prompts for each)
flac-cue-split /path/to/music --execute --delete

# Split and delete without prompts
flac-cue-split /path/to/music --execute --delete --yes

# Delete sources for already-split albums
flac-cue-split /path/to/music --delete --yes
```

### Example Output

```
Found 2 album(s) in Music/

 1. The Elder Scrolls V: Skyrim - Atmospheres
    Jeremy Soule | 2 tracks | 42m 54s
    _Game OST/_Elder Scrolls/Jeremy Soule - Skyrim - Atmospheres/
    2 tracks extracted
    Delete original FLAC? [Y/n]

 2. Dark Side of the Moon
    Pink Floyd | 10 tracks | 42m 59s
    Pink Floyd/1973 - Dark Side of the Moon/
    10 tracks extracted
    Delete original FLAC? [Y/n]

Done
```

### Output Format

Tracks are saved as `{nn}. {track_name}.flac` where the number is zero-padded based on total track count (e.g., `01.` for <100 tracks, `001.` for 100-999, etc).

## Options

| Option | Description |
|--------|-------------|
| `--execute` | Actually perform the split (default is dry-run) |
| `--delete` | Delete original FLAC files after splitting (prompts for confirmation) |
| `--output`, `-o` | Output directory for split files (default: same as source) |
| `--verbose`, `-v` | Show detailed track listings |
| `--yes`, `-y` | Auto-confirm prompts (use with `--delete`) |

## Safety

- **Dry-run by default**: Nothing is modified unless you pass `--execute`
- **Deletion prompts**: `--delete` asks for confirmation unless `--yes` is specified
- **Error protection**: Source files are kept if any extraction errors occur
- **Permanent deletion**: `--delete` permanently removes files (not moved to trash)

## License

MIT
py-splat 1.0.0
Automatic GitHub issue creation + PR fix on runtime errors
Requires Python: >=3.9
Keywords: crash-reporting, debugging, django, error-tracking, exception-handling, fastapi, flask, github-issues, monitoring

# Splat

[![PyPI version](https://img.shields.io/pypi/v/py-splat.svg)](https://pypi.org/project/py-splat/)
[![Python versions](https://img.shields.io/pypi/pyversions/py-splat.svg)](https://pypi.org/project/py-splat/)
[![Documentation Status](https://readthedocs.org/projects/py-splat/badge/?version=latest)](https://py-splat.readthedocs.io/)
[![License](https://img.shields.io/pypi/l/py-splat.svg)](https://github.com/andreaslordos/splat/blob/main/LICENSE)

Splat automatically creates GitHub issues when your Flask, FastAPI, or Django app crashes, then uses Claude Code to generate fix PRs. Set it up once, and bugs fix themselves.

## Quick Start

```bash
pip install py-splat
splat init
```

The `splat init` wizard detects your framework, injects the error-catching middleware, and sets up a GitHub Action that triggers Claude Code when issues are created.

The injected code is minimal: two lines of code for each server you instantiate. `splat init` will figure out where to inject this code and do it for you.

## How It Works

1. **Runtime error occurs** → Splat middleware catches the exception
2. **GitHub issue created** → Contains error details, traceback, and los
3. **GitHub Action triggers** → Claude Code analyzes the bug and opens a fix PR

## Documentation

See the [full documentation](https://py-splat.readthedocs.io/) for configuration options and advanced usage.

## License

MIT