semvec/pypi-packages huggingface dataset:
mcp-llm-inferencer 0.1.0
Uses Claude or OpenAI API to convert prompt-mapped input into concrete MCP server components such as tools, resource templates, and prompt handlers
Requires Python: >=3.7

# mcp-llm_inferencer

Uses Claude or OpenAI API to convert prompt-mapped input into concrete MCP server components such as tools, resource templates, and prompt handlers.

## Features

- LLM call engine with retry and fallback logic
- Supports Claude and OpenAI interchangeably
- Streaming support for Claude Desktop
- Tool and resource response validation
- Structured output bundling per component

## Installation

```bash
pip install mcp-llm_inferencer
```

## Usage

```python
from mcp_llm_inferencer import Mcp_llm_inferencer

# Initialize the library
mcp_llm_inferencer_instance = Mcp_llm_inferencer()

# Use the library functions
# Example usage will be added in future versions
```

## License

MIT
sentence2simvec 0.0.1
Sentence similarity (0-1) with SBERT vectors - Python 3.10+
Requires Python: >=3.10

# sentence2simvec
Vector-based sentence similarity **(0.0 - 1.0)** for Japanese & multilingual texts.

* 3-gram Jaccard **surface** similarity
* SBERT (MiniLM) **semantic** similarity
* **Python API** + **CLI** (`sentence2simvec`)
* Can output each sentence's embedding vector (numpy, 384-dim)
* Embedding vectors for each sentence can be obtained and saved as a NumPy array.

## Install
```bash
# macOS/Linux
curl -LsSf https://astral.sh/uv/install.sh | sh
# Windows
powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"

# 3.10, 3.11, 3.12, 3.13, ...
uv venv -p 3.10 .venv
source .venv/bin/activate # Windows: .venv\Scripts\activate

uv pip install -U sentence2simvec
or
uv pip install -e .
```

## Usage
- CLI
    ```bash
    sentence2simvec "Hello!" "Hello world!" --save-vecs ./vecs

    # Similarity: 0.7135
    #    • n-gram  = 0.2727
    #    • cosine  = 0.9024
    # vecs/vec1.npy, vecs/vec2.npy written
    ```
- Python API
    ```python
    from sentence2simvec import similarity_score, sentence_vector

    # --- Similarity (with vectors) ---------------------------
    score, details, v1, v2 = similarity_score(
        "Hello!",
        "Hello world!",
        return_vectors=True
    )
    print(score)          # 0.87
    print(details)        # {'jaccard': 0.764…, 'cosine': 0.910…}
    print(v1.shape)       # (384,)

    # --- Get a single sentence vector ------------------------
    vec = sentence_vector("Hello")
    # ※ vec is L2 regularized (||vec||₂ = 1)
    ```

## Development
```bash
uv venv -p 3.10 .venv && source .venv/bin/activate
uv pip install build twine pytest ipdb sentence-transformers numpy

# debug run
python sentence2simvec/core.py "Hello!" "Hello world!"

# tests
pytest

# build
python -m build

# upload PyPI
export TWINE_USERNAME="__token__"
export TWINE_PASSWORD="pypi-..."
twine upload dist/*
unset TWINE_USERNAME TWINE_PASSWORD
```
minify-simple 0.3.0
Minificador de archivos web: js, css, html
Requires Python: >=3.10

# minify_simple
Minificador de archivos web: js, css, html

# Descripción
Inspirado en crear un script para formatear archivos web en IDEs
como Zed, que permiten una alta configuración, pero dejan los detalles
a los programas externos.

En ese sentido se crea este proyecto, que consta de un script CLI para tal fin.
Combinado con [watchdog](https://pypi.org/project/watchdog/) y las [tareas](https://zed.dev/docs/tasks) de Zed, se obtiene un complemento para el minificado automático.

Se detalla, mas abajo, la configuración completa para un entorno linux.
Análogamente es aplicable a cualquier sistema donde se ejecute python.

# Instalar
```
pip install minify-simple
```

# Usar
## Python
```
from minify_simple.minify import Language, minify

# In
code = """
<ul>
  <li>Item 1</li>
  <li>Item 2</li>
</ul>
"""

minified = minify(code, Language.HTML)

# Out
<ul><li>Item 1</li><li>Item 2</li></ul>
```

## CLI
Minificar el mismo archivo:
```
minify-cli file.js
```
Minificar con sufijo .min:
```
# In
minify-cli -s .min file.js

# Out
file.min.js
```
Minificar indicando lenguaje (por defecto no se proporciona,
se toma de la extension del archivo):
```
minify-cli -l js file.js
```

### Ayuda
Para ver todos los parámetros del script CLI:
```
minify-cli --help
```

## Zed y watchdog
### Monitor de sistema
watchmedo es la herramienta que permite monitorear las carpetas del sistema:
```
watchmedo shell-command \
  -R \
  -p '*.js;*.css' \
  --ignore-patterns '*.min.js;*.min.css' \
  -c 'echo "${watch_src_path}" && minify-cli -s .min "${watch_src_path}"' \
  [/path/folder]
```

### Tarea Zed
Para evitar problemas con las tareas de Zed es recomendable crear
un **script** [.sh | .bat | ...] para ejecutar los comandos:
```
#!/bin/sh
echo $1
minify-cli -s .min $1
```

Salida de ejemplo del script:
```
...
./path/file.js
./path/file.min.js
./path/file.css
./path/file.min.css
...
```

Recomendable asignar permiso de ejecución:
```
chmod +x /path/to/script.sh
```

Luego la tarea Zed quedaría así:
```
{
  "label": "Run Watchdog Statics",
  "command": "watchmedo",
  "args": [
    "shell-command",
    "-R",
    "-p",
    "'*.js;*.css'",
    "--ignore-patterns",
    "'*.min.js;*.min.css'",
    "-c",
    "sh /path/script.sh",
    "${watch_src_path}",
    "/path/folder"
  ],
  "use_new_terminal": false,
  "shell": "system"
}
```

Con permiso de ejecución el script se puede invocar directamente:
```
  ...
  "-c",
  "./path/script.sh"
  ...
```

### Rendimiento
La tarea consume un promedio de 9.0 MB de memoria y muy poco uso del CPU