semvec/pypi-packages huggingface dataset:
whattimeisit-mcp 0.1.0
A lightweight mcp server that tells you exactly what time is it based on your IP.
Requires Python: >=3.13

# WhatTimeIsIt MCP Server

A lightweight mcp server that tells you exactly what time is it, powered by [World Time](http://worldtimeapi.org/).

![GitHub](https://img.shields.io/github/license/kukapay/whattimeisit-mcp) 
![GitHub last commit](https://img.shields.io/github/last-commit/kukapay/whattimeisit-mcp)

## Installation

1. **Clone the Repository**
   ```bash
   git clone https://github.com/kukapay/whattimeisit-mcp.git
   ```

2. **Client Configuration**
    ```json
    {
      "mcpServers": {
        "whattimeisit": {
          "command": "uv",
          "args": ["--directory", "path/to/whattimeisit-mcp", "run", "main.py"]
        }
      }
    }
    ```
   
## Usage


### MCP Tool
The server provides a single tool:
- **Tool Name**: `what_time_is_it`
- **Description**: Returns the current time string based on the your current IP.
- **Output**: A string in ISO 8601 format (e.g., `"2025-03-17T03:17:00+11:00"`).

## License
This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.
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.
ucdp-mem 0.3.0
Unified Chip Design Platform - Memories
Requires Python: <4.0,>=3.10.0

[![PyPI Version](https://badge.fury.io/py/ucdp-mem.svg)](https://badge.fury.io/py/ucdp-mem)
[![Python Build](https://github.com/nbiotcloud/ucdp-mem/actions/workflows/main.yml/badge.svg)](https://github.com/nbiotcloud/ucdp-mem/actions/workflows/main.yml)
[![Documentation](https://readthedocs.org/projects/ucdp-mem/badge/?version=stable)](https://ucdp-mem.readthedocs.io/en/stable/?badge=stable)
[![Coverage Status](https://coveralls.io/repos/github/nbiotcloud/ucdp-mem/badge.svg?branch=main)](https://coveralls.io/github/nbiotcloud/ucdp-mem?branch=main)
[![python-versions](https://img.shields.io/pypi/pyversions/ucdp-mem.svg)](https://pypi.python.org/pypi/ucdp-mem)

# Unified Chip Design Platform - Memories

* [Documentation](https://ucdp-mem.readthedocs.io/en/stable/)
* [PyPI](https://pypi.org/project/ucdp-mem/)
* [Sources](https://github.com/nbiotcloud/ucdp-mem)
* [Issues](https://github.com/nbiotcloud/ucdp-mem/issues)

## Installation

Installing it is pretty easy:

```bash
pip install ucdp-mem
```
thegraph-mcp 0.1.0
An MCP server that powers AI agents with indexed blockchain data from The Graph.
Requires Python: >=3.13

# TheGraph MCP Server

An MCP server that powers AI agents with indexed blockchain data from [The Graph](https://thegraph.com/).

![GitHub License](https://img.shields.io/github/license/kukapay/thegraph-mcp) 
![GitHub Last Commit](https://img.shields.io/github/last-commit/kukapay/thegraph-mcp) 
![Python Version](https://img.shields.io/badge/python-3.10%2B-blue)

## Available Tools

### 1. getSubgraphSchema
Fetches the schema of a specified subgraph, providing AI agents with the context needed to generate GraphQL queries. 

**Parameters:**
- `subgraphId`: The subgraph ID (e.g., "QmZBQcF...")
- `asText`: Output format flag
  - `true`: Returns human-readable GraphQL schema
  - `false`: Returns JSON schema (default)

### 2. querySubgraph
Executes GraphQL queries against a specified subgraph. While queries are typically generated by AI, you can also manually craft your own.

**Parameters:**
- `subgraphId`: The subgraph ID
- `query`: GraphQL query string


## Installation

1. **Clone the Repository**
    ```bash
    git clone https://github.com/kukapay/thegraph-mcp.git
    ```
2. **Client Configuration**
    ```json
    {
      "mcpServers": {
        "thegraph-mcp": {
          "command": "uv",
          "args": ["--directory", "path/to/thegraph-mcp", "run", "main.py"],
          "env": {
            "THEGRAPH_API_KEY": "your_api_key_here"
          }
        }
      }
    }
    ```

## Example Prompts

Here are some natural language prompts to trigger the tools:

### Schema Queries
- "Show me the schema for subgraph QmZBQcF... in a readable format"
- "What's the structure of the QmZBQcF... subgraph? Please display it in GraphQL format"
- "I need to understand the data model of subgraph QmZBQcF..., can you fetch its schema?"

### Data Queries
- "Find the top 5 tokens by trading volume in the last 24 hours from subgraph QmZBQcF..."
- "Show me all pairs with liquidity greater than 1 million USD in subgraph QmZBQcF..."
- "Get the latest 10 swap events from the QmZBQcF... subgraph, including token symbols and amounts"

### Analysis Tasks
- "Analyze the trading volume of USDT pairs in the last week using subgraph QmZBQcF..."
- "Compare the liquidity of ETH and USDC pairs in subgraph QmZBQcF..."
- "Find unusual trading patterns in the last 24 hours from subgraph QmZBQcF..."

### Combined Tasks
- "First get the schema of QmZBQcF..., then help me write a query to find high-value transactions"
- "Check the schema of QmZBQcF... and tell me what fields are available for querying token prices"
- "Using subgraph QmZBQcF..., analyze the market impact of large trades by first understanding the schema and then querying relevant events"

## License
This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.
striprtf 0.0.29
A simple library to convert rtf to text
Requires Python: >=3.8
Keywords: rtf

# striprtf
![Build status](https://github.com/joshy/striprtf/workflows/striprtf%20build/badge.svg)

## Purpose
This is a library to convert Rich Text Format (RTF) files to plain text files. A lot of medical documents are written in RTF format which is not ideal for parsing and further processing. This library converts it to plain old text.

## How to use it
```python
from striprtf.striprtf import rtf_to_text
rtf = "some rtf encoded string"
text = rtf_to_text(rtf)
print(text)
```

If you want to use a different encoding than `cp1252` you can pass it via the `encoding`
parameter. This is only taken into account if no explicit codepage has been set. 
```python
from striprtf.striprtf import rtf_to_text
rtf = "some rtf encoded string in latin1"
text = rtf_to_text(rtf, encoding="latin-1")
print(text)
```

Sometimes UnicodeDecodingErrors can happen because of various reasons.
In this case you can try to relax the encoding process like this:
```python
from striprtf.striprtf import rtf_to_text
rtf = "some rtf encoded string"
text = rtf_to_text(rtf, errors="ignore")
print(text)
```

## Online version
If you don't want to install or just try it out there is an [online version](https://striprtf.dev) available. 

## PostgreSQL 
There is also a [PostgreSQL version](https://github.com/MnhnL/pg_striprtf) available from [Raffael Mancini](https://github.com/raffael-mnhn).

## History
[Pyth](https://github.com/brendonh/pyth) was not working for the rtf files I
had. The next best thing was this gist:
https://gist.github.com/gilsondev/7c1d2d753ddb522e7bc22511cfb08676

~~Very few additions where made, e.g. better formatting of tables. ~~

In the meantime some encodings bugs have been fixed. :-)
opcua-mcp 0.1.0
An MCP server that connects AI agents to OPC UA-enabled industrial systems.
Requires Python: >=3.13

# OPC UA MCP Server

An MCP server that connects to OPC UA-enabled industrial systems, allowing AI agents to monitor, analyze, and control operational data in real time.

This project is ideal for developers and engineers looking to bridge AI-driven workflows with industrial automation systems.

![GitHub License](https://img.shields.io/github/license/kukapay/opcua-mcp)
![Python Version](https://img.shields.io/badge/python-3.10+-blue)
![Status](https://img.shields.io/badge/status-active-brightgreen.svg)

## Features

- **Read OPC UA Nodes**: Retrieve real-time values from industrial devices.
- **Write to OPC UA Nodes**: Control devices by writing values to specified nodes.
- **Seamless Integration**: Works with MCP clients like Claude Desktop for natural language interaction.


### Tools
The server exposes two tools:
- **`read_opcua_node`**:
  - **Description**: Read the value of a specific OPC UA node.
  - **Parameters**:
    - `node_id` (str): OPC UA node ID (e.g., `ns=2;i=2`).
  - **Returns**: A string with the node ID and its value (e.g., "Node ns=2;i=2 value: 42").

- **`write_opcua_node`**:
  - **Description**: Write a value to a specific OPC UA node.
  - **Parameters**:
    - `node_id` (str): OPC UA node ID (e.g., `ns=2;i=3`).
    - `value` (str): Value to write (converted based on node type).
  - **Returns**: A success or error message (e.g., "Successfully wrote 100 to node ns=2;i=3").

### Example Prompts

- "What’s the value of node ns=2;i=2?" → Returns the current value.
- "Set node ns=2;i=3 to 100." → Writes 100 to the node.

## Installation

### Prerequisites
- Python 3.10 or higher
- An OPC UA server (e.g., a simulator or real industrial device)

### Install Dependencies
Clone the repository and install the required Python packages:

```bash
git clone https://github.com/kukapay/opcua-mcp.git
cd opcua-mcp
pip install asyncua mcp[cli]
```

### MCP Client Configuration

```json
{
 "mcpServers": {
   "opcua-mcp": {
     "command": "python",
     "args": ["path/to/opcua_mcp/main.py"],
     "env": {
        "OPCUA_SERVER_URL": "your-opc-ua-server-url"
     }
   }
 }
}
```


## License
This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.