semvec/pypi-packages huggingface dataset:
virapi 0.1.0
A light and fast ASGI web framework
Requires Python: >=3.9
Keywords: asgi, web, framework, http, api

# virapi 🚀

A lightweight and fast ASGI web framework built from scratch with FastAPI-inspired design.

## ✨ Features

- 🔗 **FastAPI-Style API**: Familiar decorators (`@app.get`, `@app.post`) and patterns
- 🎯 **Advanced Routing**: Path parameters with type conversion (`{id:int}`, `{name:str}`)
- 🔧 **Modular Design**: Organize code with `APIRouter` and prefixes
- 🛠️ **Middleware System**: Request/response pipeline with built-in middleware
- 📡 **ASGI 3.0 Compatible**: Works with uvicorn, hypercorn, and other ASGI servers
- 🔄 **Full Request/Response**: JSON, forms, file uploads, cookies, headers
- 🧪 **Testing Framework**: Built-in test client for easy endpoint testing
- 📚 **Excellent Documentation**: Every component is thoroughly documented

## 🚀 Quick Start

```python
from virapi import Virapi, json_response

app = Virapi()

@app.get("/")
async def home(request):
    return json_response({"message": "Hello, virapi!"})

@app.get("/users/{user_id:int}")
async def get_user(user_id: int, request):
    return json_response({"user_id": user_id, "type": type(user_id).__name__})

# Run with: uvicorn main:app --reload
```

## 🏗️ Architecture Overview

```
virapi/
├── virapi.py          # Main application class
├── request/             # Request handling & file uploads
├── response.py          # Response building & content types
├── routing/             # Advanced routing system
├── middleware/          # Middleware chain & built-ins
├── testing/             # Test client & utilities
└── status.py           # HTTP status codes
```

## 📚 Learn More

- **[Complete Documentation](docs/README.md)** - Detailed guides and examples
- **[Routing Guide](docs/ROUTING_GUIDE.md)** - Advanced routing patterns
- **[Middleware Guide](docs/MIDDLEWARE_GUIDE.md)** - Custom middleware development
- **[Examples](examples/)** - Real-world application examples

## 🛠️ Installation & Development

```bash
# Clone the repository
git clone https://github.com/victorgomez09/virapi.git
cd virapi

# Install development dependencies
pip install -e ".[dev]"

# Run tests
pytest

# Run examples
python examples/complete_example.py
```

## 🤝 Contributing

This is an educational project! Contributions that improve code clarity, add educational value, or enhance documentation are especially welcome.

## 📄 License

MIT License - Feel free to use this code for learning and teaching!
llm-watermark 0.1.18
easy way to use llm watermarking techniques
Requires Python: >=3.10
Keywords: AI, ML, LLM

this is the initial version for myself usage

example usage:
```python
from llm_watermark import assembly_qwen3, huggingface_model


wm_model: huggingface_model = assembly_qwen3("8B")
prompt = "Write a short story about a robot learning to love."
messages = [{"role": "user", "content": prompt}]

wm_response = wm_model.generate(messages, do_watermark=True, max_new_tokens=256)
print("Watermarked Response:", wm_response)
print(wm_model.detect_watermark(wm_response))
print("----------------")

non_wm_response = wm_model.generate(messages, do_watermark=False, max_new_tokens=256)
print("Non-Watermarked Response:", non_wm_response)
print(wm_model.detect_watermark(non_wm_response))
```
adsdatahub 0.0.7
Ads Data Hub API client for Python
Requires Python: >=3.11

# Ads Data Hub API client for Python

[![pypi package](https://badge.fury.io/py/adsdatahub.svg)](https://pypi.org/project/adsdatahub)

## Usage

Please refer to the [examples](https://github.com/ya7010/adsdatahub-py/tree/main/adsdatahub/examples).
mcp-echo-server 0.1.1
A simple MCP server with an echo tool
Requires Python: >=3.12

# MCP Test Server

mcp-name: io.github.bharath-krishna/mcp-test

A simple Model Context Protocol (MCP) server with an echo tool for testing purposes.

## Features

- **Echo Tool**: Returns back any message you send to it

## Installation

```bash
pip install mcp-echo-server
```

## Usage

Add this server to your MCP client configuration:

```json
{
  "mcpServers": {
    "mcp-echo-server": {
      "command": "mcp-echo-server"
    }
  }
}
```

## Development

Install in development mode:

```bash
uv pip install -e .
```

## Tools

### echo

Echoes back the provided message.

**Input:**
- `message` (string, required): The message to echo back

**Example:**
```json
{
  "message": "Hello, world!"
}
```

**Output:**
```
Echo: Hello, world!
```
rl-simple-teerth 0.1.0
Simple RL utilities for epsilon-greedy and TD error
Requires Python: >=3.6

\# RL Simple Package by Teerth



A simple Python package for Reinforcement Learning utilities created by \*\*Teerth\*\* for academic assignment.



\## Installation



pip install rl\_simple\_teerth





\## Features



\- \*\*Epsilon-Greedy Action Selection\*\*: Balance exploration and exploitation

\- \*\*TD Error Calculation\*\*: Compute temporal difference errors



\## Usage



from rl\_simple import epsilon\_greedy\_action, calculate\_td\_error



Epsilon-greedy selection

Q\_values = \[0.1, 0.8, 0.3]

action = epsilon\_greedy\_action(Q\_values, epsilon=0.1)

print(f"Selected action: {action}")



TD error

td\_error = calculate\_td\_error(reward=1.0, gamma=0.9,

current\_value=0.5, next\_value=0.8)

print(f"TD Error: {td\_error}")





\## Author



\*\*Teerth\*\*  

Created for Reinforcement Learning Assignment
iflow-mcp_nearby-search-mcp 0.1.0
An MCP server for nearby place searches with IP-based location detection.
Requires Python: >=3.13

# NearbySearch MCP Server

An MCP server for nearby place searches with IP-based location detection.

![GitHub License](https://img.shields.io/github/license/kukapay/nearby-search-mcp) 
![GitHub Last Commit](https://img.shields.io/github/last-commit/kukapay/nearby-search-mcp) 
![Python Version](https://img.shields.io/badge/python-3.10%2B-blue)

## Features

- **IP-based Location Detection**: Uses ipapi.co to determine your current location
- **Google Places Integration**: Searches for nearby places based on keywords and optional type filters
- **Simple Interface**: Single tool endpoint with customizable radius

## Requirements

- Python 3.10+
- Google Cloud Platform API Key with Places API enabled
- Internet connection

## Installation

1. Clone the repository:
```bash
git clone https://github.com/kukapay/nearby-search-mcp.git
cd nearby-search-mcp
```

2. Install dependencies:
```bash
# Using uv (recommended)
uv add "mcp[cli]" httpx python-dotenv

# Or using pip
pip install mcp httpx python-dotenv
```

3. Client Configuration

```json
{
  "mcpServers": {
    "nearby-search": {
      "command": "uv",
      "args": ["--directory", "path/to/nearby-search-mcp", "run", "main.py"],
      "env": {
        "GOOGLE_API_KEY": "your google api key"
      }
    }
  }
}
````

## Usage

### Running the Server

- **Development Mode** (with MCP Inspector):
```bash
mcp dev main.py
```

- **Install in Claude Desktop**:
```bash
mcp install main.py --name "NearbySearch"
```

- **Direct Execution**:
```bash
python main.py
```

### Available Endpoints

**Tool: `search_nearby`**
 - Searches for places near your current location
 - Parameters:
   - `keyword` (str): What to search for (e.g., "coffee shop")
   - `radius` (int, optional): Search radius in meters (default: 1500)
   - `type` (str, optional): Place type (e.g., "restaurant", "cafe")


## License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
iflow-mcp_dune-analytics-mcp 0.1.0
A mcp server that bridges Dune Analytics data to AI agents.
Requires Python: >=3.13

# Dune Analytics MCP Server

[![smithery badge](https://smithery.ai/badge/@kukapay/dune-analytics-mcp)](https://smithery.ai/server/@kukapay/dune-analytics-mcp)

A mcp server that bridges Dune Analytics data to AI agents.

## Features

- **Tools**: 
  - `get_latest_result`: Fetch the latest results of a Dune query by ID.
  - `run_query`: Execute a Dune query by ID and retrieve results.
- **CSV Output**: All results are returned as CSV-formatted strings for easy processing.

## Prerequisites

- Python 3.10+
- A valid Dune Analytics API key (get one from [Dune Analytics](https://dune.com/settings/api))

## Installation

### Installing via Smithery

To install Dune Analytics for Claude Desktop automatically via [Smithery](https://smithery.ai/server/@kukapay/dune-analytics-mcp):

```bash
npx -y @smithery/cli install @kukapay/dune-analytics-mcp --client claude
```

### Manual Installation

1. **Clone the Repository**:
   ```bash
   git clone https://github.com/kukapay/dune-analytics-mcp.git
   cd dune-analytics-mcp
   ```

2. **Set Up Environment Variables**:
   Create a `.env` file in the project root:
   ```
   DUNE_API_KEY=your_api_key_here
   ```
   Alternatively, set it as a system environment variable:
   ```bash
   export DUNE_API_KEY="your_api_key_here"
   ```

## Usage

### Running the Server

- **Development Mode**:
  ```bash
  mcp dev main.py
  ```
  This starts the server with hot reloading for development.

- **Install for Claude Desktop**:
  ```bash
  mcp install main.py --name "Dune Analytics"
  ```
  Installs the server as a service for use with Claude Desktop.

### Tool Usage

1. **`get_latest_result(query_id)`**
   - **Description**: Retrieves the latest results of a specified Dune query.
   - **Input**: `query_id` (int) - The ID of the Dune query.
   - **Output**: CSV-formatted string of the query results.
   - **Example**:
     ```
     get_latest_result(query_id=4853921)
     ```

2. **`run_query(query_id)`**
   - **Description**: Executes a Dune query and returns the results.
   - **Input**: `query_id` (int) - The ID of the Dune query to run.
   - **Output**: CSV-formatted string of the query results.
   - **Example**:
     ```
     run_query(query_id=1215383)
     ```

### Example Commands in Claude Desktop

- "Get latest results for dune query 1215383"
- "Run dune query 1215383"


## License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
iflow-mcp_mcp-python 0.1.3
MCP server providing a Python REPL with persistent session
Requires Python: >=3.10
Keywords: mcp, python, repl, server

# Python REPL MCP Server

This MCP server provides a Python REPL (Read-Eval-Print Loop) as a tool. It allows execution of Python code through the MCP protocol with a persistent session.

## Setup

No setup needed! The project uses `uv` for dependency management.

## Running the Server

Simply run:

```bash
uv run src/python_repl/server.py
```

## Usage with Claude Desktop

Add this configuration to your Claude Desktop config file:

```json
{
  "mcpServers": {
    "python-repl": {
      "command": "uv",
      "args": [
        "--directory",
        "/absolute/path/to/python-repl-server",
        "run",
        "mcp_python"
      ]
    }
  }
}
```

The server provides three tools:

1. `execute_python`: Execute Python code with persistent variables

   - `code`: The Python code to execute
   - `reset`: Optional boolean to reset the session

2. `list_variables`: Show all variables in the current session

3. `install_package`: Install a package from pypi

## Examples

Set a variable:

```python
a = 42
```

Use the variable:

```python
print(f"The value is {a}")
```

List all variables:

```python
# Use the list_variables tool
```

Reset the session:

```python
# Use execute_python with reset=true
```

## Contributing

Contributions are welcome! Please feel free to submit a Pull Request. Here are some ways you can contribute:

- Report bugs
- Suggest new features
- Improve documentation
- Add test cases
- Submit code improvements

Before submitting a PR, please ensure:

1. Your code follows the existing style
2. You've updated documentation as needed
3. Maybe write some tests?

For major changes, please open an issue first to discuss what you would like to change.
iflow-mcp_bloodhound-mcp 0.1.0
Add your description here
Requires Python: >=3.13

# BloodHound MCP
BloodHound MCP (Model Context Protocol) is an innovative extension of the BloodHound tool, designed to enable Large Language Models (LLMs) to interact with and analyze Active Directory (AD) and Azure Active Directory (AAD) environments through natural language queries. By leveraging the power of LLMs, BloodHound MCP allows users to perform complex queries and retrieve insights from their AD/AAD environments using simple, conversational commands.

## Features
- **Natural Language Queries**: Use conversational language to query your AD/AAD environment without needing to write Cypher queries manually.
- **LLM-Powered Analysis**: Harness the capabilities of Large Language Models to interpret and execute queries on your behalf.
- **Seamless Integration**: Works with existing BloodHound data stored in Neo4j, providing a user-friendly interface for complex analysis.
- **Customizable**: Easily configure the system to work with your specific environment and tools.

## Configure the MCP Server
```json
{
  "mcpServers": {
    "BloodHound": {
      "name": "BloodHound",
      "isActive": true,
      "command": "uv",
      "args": [
        "run",
        "--with",
        "mcp[cli],neo4j",
        "mcp",
        "run",
        "<PATH_TO_THE_PROJECT>server.py"
      ],
      "env": {
        "BLOODHOUND_URI": "bolt://localhost:7687",
        "BLOODHOUND_USERNAME": "neo4j",
        "BLOODHOUND_PASSWORD": "bloodhound"
      }
    }
  }
}
```


## Usage
![](img/1.png)
![](img/2.png)
![](img/3.png)

## Configuration
To customize BloodHound MCP, update the configuration file in your MCP-supported tool. Key settings include:

- Neo4j Database Connection:
    - `BLOODHOUND_URI`: The URI of your Neo4j database (e.g., bolt://localhost:7687).
    - `BLOODHOUND_USERNAME`: Your Neo4j username.
    - `BLOODHOUND_PASSWORD`: Your Neo4j password.
- Server Settings: Adjust the command and args to match your environment and tool requirements.

## Contributing
We welcome contributions to BloodHound MCP! To get involved:

1. Fork the Repository: Create your own copy on GitHub.
2. Create a Branch: Work on your feature or fix in a new branch.
3. Submit a Pull Request: Include a clear description of your changes.


## Special Thanks
Custom queries from : https://github.com/CompassSecurity/BloodHoundQueries