semvec/pypi-packages huggingface dataset:
ragflow-mcp-server-v0-2-0 0.2.0
RAGFlow MCP Server V0.2.0
Requires Python: >=3.10

# ragflow-mcp-server-v0.2.0 MCP server

RAGFlow MCP Server V0.2.0

## Components

### Resources

The server implements a simple note storage system with:
- Custom note:// URI scheme for accessing individual notes
- Each note resource has a name, description and text/plain mimetype

### Prompts

The server provides a single prompt:
- summarize-notes: Creates summaries of all stored notes
  - Optional "style" argument to control detail level (brief/detailed)
  - Generates prompt combining all current notes with style preference

### Tools

The server implements one tool:
- add-note: Adds a new note to the server
  - Takes "name" and "content" as required string arguments
  - Updates server state and notifies clients of resource changes

## Configuration

[TODO: Add configuration details specific to your implementation]

## Quickstart

### Install

#### Claude Desktop

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

<details>
  <summary>Development/Unpublished Servers Configuration</summary>
  ```
  "mcpServers": {
    "ragflow-mcp-server-v0.2.0": {
      "command": "uv",
      "args": [
        "--directory",
        "D:\AIGC\Projects\ragflow-mcp-server-v0.2.0",
        "run",
        "ragflow-mcp-server-v0.2.0"
      ]
    }
  }
  ```
</details>

<details>
  <summary>Published Servers Configuration</summary>
  ```
  "mcpServers": {
    "ragflow-mcp-server-v0.2.0": {
      "command": "uvx",
      "args": [
        "ragflow-mcp-server-v0.2.0"
      ]
    }
  }
  ```
</details>

## Development

### Building and Publishing

To prepare the package for distribution:

1. Sync dependencies and update lockfile:
```bash
uv sync
```

2. Build package distributions:
```bash
uv build
```

This will create source and wheel distributions in the `dist/` directory.

3. Publish to PyPI:
```bash
uv publish
```

Note: You'll need to set PyPI credentials via environment variables or command flags:
- Token: `--token` or `UV_PUBLISH_TOKEN`
- Or username/password: `--username`/`UV_PUBLISH_USERNAME` and `--password`/`UV_PUBLISH_PASSWORD`

### Debugging

Since MCP servers run over stdio, debugging can be challenging. For the best debugging
experience, we strongly recommend using the [MCP Inspector](https://github.com/modelcontextprotocol/inspector).


You can launch the MCP Inspector via [`npm`](https://docs.npmjs.com/downloading-and-installing-node-js-and-npm) with this command:

```bash
npx @modelcontextprotocol/inspector uv --directory D:\AIGC\Projects\ragflow-mcp-server-v0.2.0 run ragflow-mcp-server-v0-2-0
```


Upon launching, the Inspector will display a URL that you can access in your browser to begin debugging.
molabel 0.1.5
A simple annotation widget for labeling examples
Requires Python: >=3.8

# molabel

A simple annotation widget for labeling examples with speech recognition support.

For an interactive demo check GitHub pages [here](https://koaning.github.io/molabel/). 

## Features

![localhost_2719_](https://github.com/user-attachments/assets/58c9622d-e497-4965-a564-b8340e66da90)

- **Interactive annotation**: <kbd>Yes</kbd>/<kbd>No</kbd>/<kbd>Skip</kbd> buttons with <kbd>Previous</kbd> navigation
- **Keyboard shortcuts**: Alt+1-6 for quick navigation and actions
- **Gamepad support**: Controller input with push-to-talk speech
- **Notes field**: Text annotations with live speech transcription

## Installation

```bash
uv pip install molabel
```

## Usage

```python
from molabel import SimpleLabel

def render_example(example):
    return f"<p>{example['text']}</p>"

# Create annotation widget
widget = SimpleLabel(
    examples=[{"text": "example 1"}, {"text": "example 2"}],
    render=render_example,
    notes=True
)

# Display in notebook
widget

# Get annotations after labeling
annotations = widget.get_annotations()
```

### Custom Shortcuts

```python
widget = SimpleLabel(
    examples=examples,
    render=render_example,
    shortcuts={"Alt+Q": "prev", "Alt+W": "yes"},  # Custom keyboard
    gamepad_shortcuts={"button_7": "yes"}  # Custom gamepad
)
```

If you're keen to understand your gamepad better and how to map the buttons to actions, you can check [this notebook](https://koaning.github.io/mopad/). It will show every name of every button that you press in real time via the browser gamepad API. 

## Controls

- **Mouse**: Click buttons or microphone icon
- **Keyboard**: Alt+1 (prev), Alt+2 (yes), Alt+3 (no), Alt+4 (skip), Alt+5 (focus notes), Alt+6 (speech toggle)
- **Gamepad**: Button mappings with push-to-talk speech on left trigger

You can assign keyboard/gamepad shortcuts to the widget for all the possible actions: 

- `prev` - go to the previous example
- `yes` - label the example as yes
- `no` - label the example as no
- `skip` - skip the example
- `focus_notes` - focus the notes field
- `speech_notes` - start/stop speech recognition

## Requirements

- Modern web browser for Speech Recognition/Gamepad API support
- Microphone access for speech features
gradio-headinjector 0.0.3
A head injector for css and js
Requires Python: >=3.10
Keywords: gradio-custom-component, gradio-template-Fallback

---
tags: [gradio-custom-component, ]
title: gradio_headinjector
short_description: A Head injector for css and js
colorFrom: blue
colorTo: yellow
sdk: gradio
pinned: false
app_file: space.py
---

# `gradio_headinjector`
<a href="https://pypi.org/project/gradio_headinjector/" target="_blank"><img alt="PyPI - Version" src="https://img.shields.io/pypi/v/gradio_headinjector"></a>  

A head injector for css and js

## Installation

```bash
pip install gradio_headinjector
```

## Usage

```python
import gradio as gr
from gradio_headinjector import HeadInjector

def inject_assets():
    """
    This function prepares the payload of CSS and JS code. It's called by the
    demo.load() event listener when the Gradio app starts.
    """
    # Inline code
    css_code = "body { background-color: #f0f5ff !important; }"
    js_code = "console.log('Hello from an inline JS string!');"

    # Read from files
    try:
        with open("test.css", "r", encoding="utf-8") as f:
            css_code += f.read() + "\n"
        with open("test.js", "r", encoding="utf-8") as f:
            js_code += f.read() + "\n"
    except FileNotFoundError as e:
        print(f"Warning: Could not read asset file: {e}")

    return {"js": js_code, "css": css_code}


with gr.Blocks() as demo:
    gr.Markdown("# Application with HeadInjector")
    gr.Markdown("If the background is light blue and the buttons trigger an alert, it worked!")
    
    # 1. Instantiate the component. It is empty at this point.
    head_injector = HeadInjector()
    
    with gr.Row():
        gr.Button("Button 1")
        gr.Button("Button 2")

    gr.Textbox(label="Check your browser's developer console (F12) for JS messages.")

    # 2. Use the `demo.load()` event to populate the component.
    # This is the reliable pattern: `demo.load` runs the `inject_assets` function
    # and sends its return value to the `head_injector` component.
    demo.load(fn=inject_assets, inputs=None, outputs=[head_injector])


# Launch the application
if __name__ == '__main__':
    demo.launch()
```

## `HeadInjector`

### Initialization

<table>
<thead>
<tr>
<th align="left">name</th>
<th align="left" style="width: 25%;">type</th>
<th align="left">default</th>
<th align="left">description</th>
</tr>
</thead>
<tbody></tbody></table>




### User function

The impact on the users predict function varies depending on whether the component is used as an input or output for an event (or both).

- When used as an Input, the component only impacts the input signature of the user function.
- When used as an output, the component only impacts the return signature of the user function.

The code snippet below is accurate in cases where the component is used as both an input and an output.



 ```python
 def predict(
     value: Any
 ) -> typing.Optional[typing.Dict[str, str]][
    typing.Dict[str, str][str, str], None
]:
     return value
 ```
telemaster 1.1.0
Telemaster — easy Python library for logs management in Telegram.

## **Telemaster – Telegram logging utility**  

---

A simple Python tool for delivering logs, status updates, and files to Telegram admins.  

#### **Installation**  
```bash  
pip install telemaster  
```  

#### **Quick Start**  
```python  
import telemaster  

logger = telemaster.TeleLogs(  
    bot_token="YOUR_BOT_TOKEN",  
    log_file_path="app.log",  
    admin_chat_ids=[1234567890, 9876543210]  
)  

logger.send_message_to_all("Service is online!")  
```  

#### **Key Features**  
- **Real-time alerts** – Notify admins instantly  
- **Log forwarding** – Send log files directly to Telegram  
- **Graceful shutdown reports** – Automatic alerts on exit  

#### **Best Practices**  
- Store credentials securely (e.g., environment variables)  
- Restrict access to trusted admin chats  
- Implement log rotation  

---

## License

MIT License - Free for commercial and personal use.