semvec/pypi-packages huggingface dataset:
cerberus-monitor 2025.12.20190018
Cerberus: A Simplified Network Monitoring Solution that Empowers Users to Extract Insightful Insights from Network Activity in Real-Time.
License: MIT
Requires Python: >=3.9

# Cerberus Monitor [![PyPI version](https://badge.fury.io/py/cerberus-monitor.svg)](https://pypi.org/project/cerberus-monitor/) [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT) [![Downloads](https://img.shields.io/pypi/dm/cerberus-monitor.svg)](https://pypi.org/project/cerberus-monitor/) [![LinkedIn](https://img.shields.io/badge/LinkedIn-Connect-blue)](https://www.linkedin.com/in/eugeevstafev/)

Cerberus Monitor is a lightweight Python package designed to process and interpret network monitoring insights using advanced language models. It allows users to extract structured data from natural language prompts related to network activity analysis, leveraging the power of the langchain_llm7 library with support for flexible LLM integrations.

## Installation

```bash
pip install cerberus-monitor
```

## Usage

Here is a basic example of how to use the package:

```python
from cerberus_monitor import cerberus-monitor

user_input = "Analyze recent network traffic for anomalies."
response = cerberus_monitor(user_input)
print(response)
```

## Function Parameters

- **user_input** (`str`): The text describing the network analysis query or command.
- **llm** (`Optional[BaseChatModel]`): An optional instance of a language model from langchain (e.g., OpenAI, Anthropic). If not provided, the function defaults to using `ChatLLM7` from `langchain_llm7`.
- **api_key** (`Optional[str]`): The API key for LLM7 service. This can be set via environment variable `LLM7_API_KEY` or passed directly.

## Notes on LLM Support

This package utilizes `ChatLLM7` from `langchain_llm7` which supports multiple providers such as:

```python
from langchain_openai import ChatOpenAI
from langchain_anthropic import ChatAnthropic
from langchain_google_genai import ChatGoogleGenerativeAI
```

For example, to use OpenAI:

```python
from langchain_openai import ChatOpenAI
from cerberus_monitor import cerberus_monitor

llm = ChatOpenAI()
response = cerberus_monitor(user_input, llm=llm)
```

Similarly, it supports other LLMs by passing their instances into the `llm` parameter.

## Rate Limits

The default free-tier rate limits for LLM7 are sufficient for most uses. For higher rate limits, set your LLM7 API key via:

- Environment variable: `LLM7_API_KEY`
- Or directly in code:

```python
response = cerberus_monitor(user_input, api_key="your_api_key")
```

You can obtain a free API key by registering at [https://token.llm7.io/](https://token.llm7.io/).

## Related Resources

- [langchain_llm7 Documentation](https://pypi.org/project/langchain_llm7/)
- [GitHub Issues](https://github.com/chigwell/cerberus-monitor/issues)

## Author

**Eugene Evstafev**  
Email: [hi@eugene.plus](mailto:hi@eugene.plus)  
GitHub: [chigwell](https://github.com/chigwell)
aiwatermarkremover 2025.12.20185814
**The Package** is a specialized tool designed to help users **detect and remove AI-generated watermarks** from text—particularly those embedded by models like Gemini—while preserving the original mea
License: MIT
Requires Python: >=3.9

# aiwatermarkremover

## Overview

**Detect and remove AI-generated watermarks** from text with this specialized tool. Perfect for developers, researchers, or anyone who needs to reprocess AI outputs for human consumption, further analysis, or compliance without losing context.

## Installation

```bash
pip install aiwatermarkremover
```

## Usage

```python
from aiwatermarkremover import aiwatermarkremover

response = aiwatermarkremover(user_input)
```

### Parameters

* `user_input`: str - The user input text to process
* `llm`: Optional[BaseChatModel] - The langchain LLM instance to use (default: `ChatLLM7` from `langchain_llm7`)
* `api_key`: Optional[str] - The API key for LLM7 (default: uses a free tier API key or the `LLM7_API_KEY` environment variable, or `None` for a local LLM instance)

### Using a custom LLM

You can safely pass your own LLM instance (based on [langchain](https://docs.langchain.com/)) via the `llm` parameter:

```python
from langchain_openai import ChatOpenAI
from aiwatermarkremover import aiwatermarkremover

llm = ChatOpenAI()
response = aiwatermarkremover(user_input, llm=llm)
```

or for example to use the Anthropic:

```python
from langchain_anthropic import ChatAnthropic
from aiwatermarkremover import aiwatermarkremover

llm = ChatAnthropic()
response = aiwatermarkremover(user_input, llm=llm)
```

or Google Generative AI:

```python
from langchain_google_genai import ChatGoogleGenerativeAI
from aiwatermarkremover import aiwatermarkremover

llm = ChatGoogleGenerativeAI()
response = aiwatermarkremover(user_input, llm=llm)
```

## LLM7 API Key

The default rate limits for LLM7 free tier are sufficient for most use cases. If you need higher rate limits, you can pass your own API key via the `api_key` parameter or environment variable `LLM7_API_KEY`.

## Credits

Author: Eugene Evstafev (github: @chigwell)
Email: hi@euegne.plus
GitHub: https://github.com/chigwell

## LICENSE

Licensed under the MIT License (https://opensource.org/licenses/MIT)

## Links

Project: [https://github.com/chigwell/aiwatermarkremover](https://github.com/chigwell/aiwatermarkremover)
LLM7 API Key: https://token.llm7.io/

[![PyPI version](https://badge.fury.io/py/aiwatermarkremover.svg)](https://badge.fury.io/py/aiwatermarkremover)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
[![Downloads](https://static.pepy.tech/api/charts/aiwatermarkremover/month/short)](https://pepy.tech/project/aiwatermarkremover)
[![LinkedIn](https://img.shields.io/badge/LinkedIn-Open%20Source-%2300ff00.svg)](https://www.linkedin.com/in/eugene-evstafev-1595a3ba)
kafka-ops-guide 2025.12.20185738
A new package that provides structured, reliable summaries of technical concepts related to Kafka operations, such as partition management. It takes user-provided text (e.g., a query about increasing 
License: MIT
Requires Python: >=3.9

# Kafka Ops Guide

Structured Summaries for Kafka Operations
=====================================

A new package that provides reliable summaries of technical concepts related to Kafka operations, such as partition management.

## Installation

```bash
pip install kafka-ops-guide
```

## Usage

```python
from kafka-ops-guide import kafka_ops_guide

user_input = "How to increase Kafka partitions?"
response = kafka_ops_guide(user_input=user_input)
print(response)
```

## Input Parameters

- `user_input: str`: The user input text to process.
- `llm: Optional[BaseChatModel]`: The langchain LLM instance to use. If not provided, the default `ChatLLM7` will be used.
- `api_key: Optional[str]`: The API key for LLM7. If not provided, the default free tier API key will be used.

## Custom LLMs

You can safely pass your own LLM instance based on [langchain](https://docs.langchain.com/) if you want to use another LLM.

For example, to use the OpenAI LLM:
```python
from langchain_openai import ChatOpenAI
from kafka-ops-guide import kafka_ops_guide

llm = ChatOpenAI()
response = kafka_ops_guide(user_input="How to increase Kafka partitions?", llm=llm)
print(response)
```

Similarly, you can use the Anthropic LLM or Google GenAI LLM.

## API Key and Rate Limits

The default rate limits for LLM7 free tier are sufficient for most use cases of this package. If you want higher rate limits for LLM7, you can pass your own API key via environment variable `LLM7_API_KEY` or via passing it directly like `kafka_ops_guide(api_key="your_api_key")`.

You can get a free API key by registering at https://token.llm7.io/

## Author and Licensing

This package is released under the MIT license. It was created by Eugene Evstafev (chigwell) and is available on GitHub at https://github.com/chigwell/kafka-ops-guide

[![PyPI version](https://img.shields.io/pypi/v/kafka-ops-guide)](https://pypi.org/project/kafka-ops-guide/)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
[![Downloads](https://img.shields.io/pypi/dm/kafka-ops-guide)](https://pypi.org/project/kafka-ops-guide/)
[![LinkedIn](https://img.shields.io/badge/LinkedIn-Connect-blue)](https://www.linkedin.com/in/chigwell/)
md-llm-lang-reader 0.2.0
Generate language-learning HTML readers (with sentence-level LLM translations and TTS) from Markdown.
License: MIT
Requires Python: >=3.9

# langreader

Generate interactive language-learning HTML readers from Markdown using LLMs.

[![en](https://img.shields.io/badge/lang-en-red.svg)](https://github.com/sekika/langreader/blob/main/README.md)
[![ja](https://img.shields.io/badge/lang-ja-blue.svg)](https://github.com/sekika/langreader/blob/main/README-ja.md)
[![fr](https://img.shields.io/badge/lang-fr-green.svg)](https://github.com/sekika/langreader/blob/main/README-fr.md)

## 👀 Demo

Before reading further, check out what this tool generates:

👉 **[Live Demo: French Reader (Alsace)](https://sekika.github.io/langreader/examples/alsace.html)**

---

`md-llm-lang-reader` (CLI command: `langreader`) converts standard Markdown text into a bilingual HTML reader. It uses Large Language Models (via [multiai](https://github.com/sekika/multiai)) to intelligently split paragraphs into natural sentences and provide translations, while adding Text-to-Speech (TTS) capabilities to every sentence.

## Features

- 🤖 **AI-Powered Translation**: Automatically splits paragraphs into natural sentences and translates them line-by-line.
- 🔊 **Text-to-Speech**: Built-in audio buttons for every source sentence (uses browser Web Speech API).
- ⏯️ **Resumable Generation**: Hit an API rate limit? Use `--continue` to resume generation exactly where it stopped.
- 📝 **Markdown Support**: Preserves headings, code blocks, and basic formatting.
- 🌍 **Wikipedia Helper**: Includes a script to easily fetch and format Wikipedia articles for learning.

## 📚 Documentation

For detailed installation instructions, CLI options, and tutorials, please visit the official documentation:

👉 **[https://sekika.github.io/langreader/](https://sekika.github.io/langreader/)**

- [**Usage Guide**](https://sekika.github.io/langreader/usage/): Options for styling, resuming, and metadata.
- [**Tutorial**](https://sekika.github.io/langreader/tutorial/): Step-by-step guide to creating a reader from a Wikipedia article.
- [**TTS Setup**](https://sekika.github.io/langreader/tts/): How to configure high-quality voices on your device.

## Installation

```bash
pip install md-llm-lang-reader
```

*Note: This tool requires [multiai](https://sekika.github.io/multiai/) configuration to access LLM providers (OpenAI, Anthropic, etc.).*

## Quick Start

1.  **Create a Markdown file (`input.md`)**:
    ```markdown
    # Bonjour
    Ceci est un exemple de phrase pour l'apprentissage.
    ```

2.  **Run the generator**:
    ```bash
    langreader -i input.md -o output.html --src fr --tgt en --provider openai --model gpt-4o-mini
    ```

3.  **Open `output.html`** in your browser to start reading and listening!

## License

MIT
architextor 2025.12.20185502
A new package designed to process and interpret structured descriptions of neural network architectures from textual input. Users provide detailed text about an ANN's innate design, such as layer type
License: MIT
Requires Python: >=3.9

# Architextor

[![PyPI version](https://img.shields.io/pypi/v/architextor.svg)](https://pypi.org/project/architextor/)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
[![Downloads](https://static.pepy.tech/badge/architextor)](https://pepy.tech/project/architextor)
[![LinkedIn](https://img.shields.io/badge/LinkedIn-Connect-blue)](https://www.linkedin.com/in/eugene-evstafev/)

A Python package for processing and interpreting structured descriptions of neural network architectures from textual input. Architextor uses pattern matching and retries to parse user-provided text about ANN designs (layer types, connections, parameters, etc.) and returns a formalized, machine-readable representation (e.g., JSON schema or graph outline).

## Installation

```bash
pip install architextor
```

## Usage

### Basic Example

```python
from architextor import architextor

user_input = "A neural network with two dense layers: first layer has 128 units and ReLU activation, second has 10 units and softmax activation."
response = architextor(user_input)
print(response)
```

### Using a Custom LLM

You can pass your own LangChain-compatible LLM instance to use OpenAI:
```python
from langchain_openai import ChatOpenAI
from architextor import architextor

llm = ChatOpenAI()
response = architextor(user_input, llm=llm)
```

use Anthropic:
```python
from langchain_anthropic import ChatAnthropic
from architextor import architextor

llm = ChatAnthropic()
response = architextor(user_input, llm=llm)
```

use Google:
```python
from langchain_google_genai import ChatGoogleGenerativeAI
from architextor import architextor

llm = ChatGoogleGenerativeAI()
response = architextor(user_input, llm=llm)
```

### Using a Custom API Key

The default LLM is ChatLLM7 (from [langchain_llm7](https://pypi.org/project/langchain-llm7/)). You can provide your own API key:

Via environment variable:
```bash
export LLM7_API_KEY="your_api_key_here"
```

Or directly in code:
```python
response = architextor(user_input, api_key="your_api_key_here")
```

Get a free API key by registering at [https://token.llm7.io/](https://token.llm7.io/).

## Parameters

- `user_input` (str): The user input text describing the neural network architecture.
- `llm` (Optional[BaseChatModel]): A LangChain LLM instance. If not provided, defaults to ChatLLM7.
- `api_key` (Optional[str]): API key for LLM7. If not provided, defaults to the `LLM7_API_KEY` environment variable.

## Default Rate Limits

The default rate limits for LLM7 free tier are sufficient for most use cases. For higher rate limits, provide your own API key.

## Issues

Report issues or feature requests on [GitHub](https://github.com/chigwell/architextor/issues).

## Author

Eugene Evstafev  
Email: hi@euegne.plus  
GitHub: [chigwell](https://github.com/chigwell)
techdisrupt-analyzer 2025.12.20185126
A new package that helps users analyze and structure their experiences or challenges with technology disruptions, such as network outages or connectivity issues. It takes a user's textual description 
License: MIT
Requires Python: >=3.9

# TechDisrupt Analyzer  

[![PyPI version](https:...  
[![License: MIT](https://im...  
[![Downloads](h...  
[![LinkedIn](ht...

TechDisrupt Analyzer is a Python package that helps users analyze and structure their experiences or challenges with technology disruptions. It takes a user's textual description of their experience and uses a Language Model (LLM) to generate a structured summary, including key details like duration, impact, and possible resolutions.  

## Installation  
```bash  
pip install techdisrupt-analyzer  
```  

## Usage  
```python  
from techdisrupt_analyzer import techdisrupt_analyzer  

# Example usage with default LLM7 
response = techdisrupt_analyzer("I spent a WEEK without IPv4")  

# Example usage with custom LLM instance (e.g., OpenAI)  
from langchain_openai import ChatOpenAI  
llm = ChatOpenAI()  
response = techdisrupt_analyzer("My internet was down for 3 hours", llm=llm)  

# Example usage with custom LLM instance (e.g., Anthropic)  
from langchain_anthropic import ChatAnthropic  
llm = ChatAnthropic()  
response = techdisrupt_analyzer("Connection failure lasting 2 days", llm=llm)  

# Example usage with custom LLM instance (e.g., Google Generative AI)  
from langchain_google_genai import ChatGoogleGenerativeAI  
llm = ChatGoogleGenerativeAI()  
response = techdisrupt_analyzer("Network outage last week", llm=llm)  
```  

## Parameters  
- `user_input` (str): The textual description of the user's experience or challenge.  
- `llm` (Optional[BaseChatModel]): The language model instance to use. Defaults to the integrated ChatLLM7. You can pass custom instances like OpenAI, Anthropic, or Google models.  
- `api_key` (Optional[str]): API key for LLM7. If not provided, the function uses the environment variable `LLM7_API_KEY` or defaults.  

## Notes on Custom LLMs  
You can pass your own LLM instances for more control or higher limits. Supported models include, but are not limited to:  
- OpenAI (`ChatOpenAI`)  
- Anthropic (`ChatAnthropic`)  
- Google Generative AI (`ChatGoogleGenAI`)  

For example:  
```python  
from langchain_openai import ChatOpenAI  
llm = ChatOpenAI(api_key='your-api-key')  
response = techdisrupt_analyzer("Sample description", llm=llm)  
```  

## License  
This project is licensed under the MIT License.  

## Author  
Eugene Evstafev (chigwell)  

## Support & Issues  
For issues and support, please visit the GitHub repository: https://github....