semvec/pypi-packages huggingface dataset:
scrapy-translate 1.3
Scrapy text translation pipeline
Requires Python: >=3.9

# scrapy-translate: Scrapy pipeline to translate item fields

It's useful if you need to translate some text from parsed items into another language. But it is also suitable for other types of text processing.

## Usage

### 1. Develop a translation service

The service should implement the following protocol to provide a mapping between the original and translated strings.

``` python
class TranslationProvider(Protocol):
    async def translate(self, strings: Collection[str], /) -> dict[str, str]: ...
```

### 2. Develop a caching service (optionally)

This may help to reduce the number of strings that need to be translated. The service should implement the following protocol.

``` python
class CacheProvider(Protocol):
    async def get(self, strings: Collection[str], /) -> dict[str, str]: ...

    async def set(self, strings: dict[str, str], /) -> None: ...
```

### 3. Add metadata to the item's class fields

The pipeline will only process the specified fields. Strings and lists of strings are supported as field values.

``` python
class Item(scrapy.Item):
    field = Field(translate=True)  # type: Union[str, list[str]]
```

It's also possible to translate HTML markup text while preserving the structure.

``` python
class Item(scrapy.Item):
    field = Field(translate=True, translate_html=True)
```

If you do want certain field values to be cached, you can specify that.

``` python
class Item(scrapy.Item):
    field = Field(translate=True, translate_cache=True)
```

### 4. Adjust project settings

Set the translation service class to the following setting.

``` python
TRANSLATION_PROVIDER = "myproject.services.MyTranslationProvider"
```

You can optionally set the caching service class. By default, there is no caching.

``` python
TRANSLATION_CACHE_PROVIDER = "myproject.services.MyCacheProvider"
```

And activate the pipeline.

``` python
ITEM_PIPELINES = {
    "scrapy_translate.pipeline.TranslatePipeline": 100,
}
```
iflow-mcp_avarant_typesense-mcp-server 0.1.0
Add your description here
Requires Python: >=3.11

# Typesense MCP Server
[![smithery badge](https://smithery.ai/badge/@avarant/typesense-mcp-server)](https://smithery.ai/server/@avarant/typesense-mcp-server)

A [Model Context Protocol](https://github.com/modelcontextprotocol/python-sdk) (MCP) Server that interfaces with [Typesense](https://typesense.org/)

## Installation

### Installing via Smithery

To install Typesense Server Integration for Claude Desktop automatically via [Smithery](https://smithery.ai/server/@avarant/typesense-mcp-server):

```bash
npx -y @smithery/cli install @avarant/typesense-mcp-server --client claude
```

### Manual Installation
Install [uv](https://docs.astral.sh/uv/getting-started/installation/)

On Mac you can install it using [homebrew](https://brew.sh/)

```shell
brew install uv
```

Clone the package

```shell
git clone git@github.com:avarant/typesense-mcp-server.git ~/typesense-mcp-server
```

Update your `.cursor/mcp.json` to use in **Cursor**

```json
{
  "mcpServers": {
    "typesense": {
      "command": "uv",
      "args": ["--directory", "~/typesense-mcp-server", "run", "mcp", "run", "main.py"],
      "env": {
        "TYPESENSE_HOST": "",
        "TYPESENSE_PORT": "", 
        "TYPESENSE_PROTOCOL": "",
        "TYPESENSE_API_KEY": ""
      }
    }
  }
}
```

## Available Tools

The Typesense MCP Server provides the following tools:

### Server Management
- `check_typesense_health` - Checks the health status of the configured Typesense server
- `list_collections` - Retrieves a list of all collections in the Typesense server

### Collection Management
- `describe_collection` - Retrieves the schema and metadata for a specific collection
- `export_collection` - Exports all documents from a specific collection
- `create_collection` - Creates a new collection with the provided schema
- `delete_collection` - Deletes a specific collection
- `truncate_collection` - Truncates a collection by deleting all documents but keeping the schema

### Document Operations
- `create_document` - Creates a single new document in a specific collection
- `upsert_document` - Upserts (creates or updates) a single document in a specific collection
- `index_multiple_documents` - Indexes (creates, upserts, or updates) multiple documents in a batch
- `delete_document` - Deletes a single document by its ID from a specific collection
- `import_documents_from_csv` - Imports documents from CSV data into a collection

### Search Capabilities
- `search` - Performs a keyword search on a specific collection
- `vector_search` - Performs a vector similarity search on a specific collection
cua-mcp-server 0.1.16
MCP Server for Computer-Use Agent (Cua)
Requires Python: <3.14,>=3.12

# Cua MCP Server

MCP server for Computer-Use Agent (Cua), enabling Cua to run through MCP clients like Claude Desktop and Cursor.

**[Documentation](https://cua.ai/docs/cua/reference/mcp-server)** - Installation, guides, and configuration.
iflow-mcp-seanivore-md-pdf-mcp 0.1.0
A Model Context Protocol (MCP) server that converts Markdown to gorgeously styled PDFs using VS Code's markdown styling and Python's ReportLab.
Requires Python: >=3.11

# md-pdf-mcp (Markdown to PDF MCP Server)

Convert Markdown to gorgeously styled PDFs using VS Code's markdown styling and Python's ReportLab.

## 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": {
    "md-pdf-mcp": {
      "command": "uv",
      "args": [
        "--directory",
        "/Users/path/to/your/local/md-pdf-mcp",
        "run",
        "md-pdf-mcp"
      ]
    }
  }
  ```
</details>

<details>
  <summary>Published Servers Configuration</summary>
  ```
  "mcpServers": {
    "md-pdf-mcp": {
      "command": "uvx",
      "args": [
        "md-pdf-mcp"
      ]
    }
  }
  ```
</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 /Users/seanivore/Development/md-pdf-mcp run md-pdf-mcp
```


Upon launching, the Inspector will display a URL that you can access in your browser to begin debugging.
kv-platform-beta 0.1.5
Python SDK for k-v.ai platform
Requires Python: >=3.10

#  KnowledgeVerse Python SDK

Official Python SDK for integrating with the **KnowledgeVerse
Platform**.\
Designed for fast integration, strong type safety, and a great developer
experience.\
This SDK is automatically generated from our API specification to ensure
it always stays up to date with the latest platform capabilities.\
Visit our [official documenation website](https://docs.k-v.ai) for more details.

------------------------------------------------------------------------

## ✨ Features

-    Fast and simple integration
-    Secure API key authentication
-    Strong typing and IDE-friendly
-    Auto-generated from official API specs
-    Pythonic and production-ready

------------------------------------------------------------------------

## 📦 Installation

### Prerequisites

Before you begin, make sure you have:

-   Python **3.10+**
-   `pip` installed
-   A valid **KnowledgeVerse Access Key**
-   Internet access

Check your Python version:

``` bash
python --version
```

Install the SDK:

``` bash
pip install kv-platform-beta
```

------------------------------------------------------------------------

## 🔐 Setup & Authentication

Generate your Access Key from the KnowledgeVerse dashboard.

Initialize the client:

``` python
from kv_platform_sdk import Client

client = Client(
    access_key="YOUR_ACCESS_KEY"
)
```

------------------------------------------------------------------------

## 🚀 Quick Start

Make your first API call:

``` python
from kv_platform_sdk import Client

client = Client(access_key="YOUR_ACCESS_KEY", timeout=10 * 60)

result = client.documents.list()
print(result)

client.close()
```

------------------------------------------------------------------------

## 📄 Requirements

-   Python 3.10+
-   Active KnowledgeVerse account

------------------------------------------------------------------------

## 📬 Support

For documentation, issues, or feature requests, please contact the
KnowledgeVerse team or visit the platform dashboard.
optifik 0.4.4
Compute film thickness from interferometry
Requires Python: >=3.10

# Optifik

Python library to compute a thickness from an interferometric spectrum.

This library replaces [oospectro](https://github.com/sciunto-org/oospectro/).

## Documentation

<https://sciunto-org.github.io/optifik/>

## Publication

We published the methodology in [EPJE Tips and Tricks (open access CC BY)](https://doi.org/10.1140/epje/s10189-025-00545-9).

To cite this paper:
```bibtex
@Article{Ziapkoff2026,
  author       = {V. Ziapkoff, F. Boulogne, A. Salonen, E. Rio},
  date         = {2026},
  journaltitle = {The European Physical Journal E},
  title        = {White light interferometry analysis for measuring thin film thickness down to a few nanometers},
  doi          = {10.1140/epje/s10189-025-00545-9},
  issn         = {1292-895X},
  number       = {1},
  pages        = {4},
  volume       = {49},
  abstract     = {We present a practical white-light interferometric method, supported by an open-source Python library optifik for automated spectrum-to-thickness deduction, enabling foam film measurements down to a few nanometers. We describe three typical spectral scenarii encountered in this method: spectra exhibiting numerous interference fringes, spectra with a moderate number of peaks, and spectra with only a few identifiable features, providing illustrative examples for each case. We also discuss the main limitations of the technique, including spectral range constraints, the necessity of knowing the refractive index, and the influence of spectral resolution and signal quality. Finally, we demonstrate the application of the method in a time-resolved study of a TTAB (tetradecyltrimethylammonium bromide) foam film undergoing elongation and thinning. This method can be adapted to measure any thin non-opaque layer.},
  refid        = {Ziapkoff2026},
}
```


## Installation

The use of pip must be limited to virtualenv


* From PyPI
```
pip install optifik
```

* From tarball
```
pip install /path/to/optifik-0.1.0.tar.gz
```

* From the source code
```
pip install .
```


## For contributors

* Install an editable version
```
pip install -e .
```

* Install dev tools
```
pip install -e ".[dev]"
```

* Run the test suite
```
pytest
```

* Install doc tools
```
pip install -e ".[docs]"
```

* Build the doc
```
sphinx-build -b html docs docs/_build/html
```

## Licence

The source code is released under the GNU General Public License v3.0.
See LICENSE for details.
iflow-mcp_letsbonk-ai_bonk-mcp 0.1.10
A MCP server for Bonk
Requires Python: >=3.11

# bonk-mcp MCP server

The bonk-mcp server implements Solana blockchain functionality for the LetsBonk launchpad.


## Features
- Token launching: launch any token on letsbonk.fun
- Token trading: buy/sell any token on letsbonk.fun

## Configuration

The bonk-mcp server can be configured in Claude Desktop by adding it to the MCP servers configuration. You'll need to provide:
- Path to the bonk-mcp directory
- Environment variables:
  - `KEYPAIR`: Your Solana keypair
  - `RPC_URL`: Solana RPC endpoint (e.g., https://api.mainnet-beta.solana.com)

## 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>
  
  ```json
  "mcpServers": {
    "bonk-mcp": {
      "command": "uv",
      "args": [
        "--directory",
        "<PATH_TO_BONK_MCP_DIRECTORY>/bonk-mcp",
        "run",
        "bonk-mcp"
      ],
      "env": {
        "KEYPAIR": "<YOUR_SOLANA_KEYPAIR>",
        "RPC_URL": "https://api.mainnet-beta.solana.com"
      }
    }
  }
  ```
</details>

<details>
  <summary>Published Servers Configuration</summary>
  
  ```json
  "mcpServers": {
    "bonk-mcp": {
      "command": "uvx",
      "args": [
        "bonk-mcp"
      ],
      "env": {
        "KEYPAIR": "<YOUR_SOLANA_KEYPAIR>",
        "RPC_URL": "https://api.mainnet-beta.solana.com"
      }
    }
  }
  ```
</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 <PATH_TO_BONK_MCP_DIRECTORY>/bonk-mcp run bonk-mcp
```

Upon launching, the Inspector will display a URL that you can access in your browser to begin debugging.

# Core contributor:
[0xwckd](https://github.com/0xwckd)
toktak-config-fetcher 1.0.0
Config utility library to fetch configuration from AWS SSM/Secrets Manager and .env files
Requires Python: >=3.12
Keywords: toktak, utils, config, aws, ssm, secrets-manager

# Toktak Config Fetcher

## Description

A Python utility library for loading configuration from AWS Systems Manager (SSM) Parameter Store, AWS Secrets Manager, and `.env` files. Provides a unified interface with caching and TTL support.

## Installation

### From PyPI

```bash
pip install toktak-config-fetcher
```

### From source

```bash
git clone <repository-url>
cd toktak_config_fetcher
pip install .
```

## Usage

```python
from toktak_config_fetcher import preload_config, get_config, get_config_int

# Preload all config from .env and AWS (optional)
preload_config()  # Loads all keys from .env file

# Or preload specific keys
preload_config(["DATABASE_URL", "PORT", "API_KEY"])

# Get string config (fetches from AWS if not cached, falls back to .env)
database_url = get_config("DATABASE_URL", default_value="sqlite:///default.db")

# Get integer config
port = get_config_int("PORT", default_value=8080)
```

## Logic Flow

1. Load all config from `.env` file.
2. Fetch values from AWS for the keys found in `.env` file (if not in local mode).
3. The values from AWS are stored in a cache.
4. The cache has a `TTL` (Time to Live) of 300 seconds. If the TTL expires, values will be fetched from AWS again.
5. The secret key must start with `SECRET_` prefix.
6. In local mode (`DEPLOY_ENV=local`), only `.env` file values are used.
7. In non-local mode, AWS values take priority over `.env` file values.

## Environment Variables

### Required Configuration

1. **`REGION`**: The AWS Region. Default value is `ap-northeast-2`
2. **`ORG`**: Organization name. Default value is `vodaplay`
3. **`DEPLOY_ENV`**: The AWS Environment. Possible values: `local`, `dev`, `stg`, `prod`. Default is `local`
4. **`APP_NAMESPACE`**: The group/namespace of this project. The config utils will combine `ORG`, `DEPLOY_ENV`, and `APP_NAMESPACE` to form the prefix for env key when getting config value from AWS

### AWS Configuration

Ensure your AWS credentials are configured via:
- AWS credentials file (`~/.aws/credentials`)
- Environment variables (`AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY`)
- IAM role (when running on EC2/ECS/Lambda)

## AWS Path Structure

- **SSM Parameters**: `/{ORG}/{DEPLOY_ENV}/{APP_NAMESPACE}/{key}` or `/{ORG}/{DEPLOY_ENV}/COMMON/{key}`
- **Secrets**: `/{ORG}/{DEPLOY_ENV}/{SECRET_key}`

## Development

```bash
# Install with development dependencies
pip install -e ".[dev,test,linting]"

# Run tests
pytest

# Run linting
flake8 toktak_config_fetcher
```