semvec/pypi-packages huggingface dataset:
kore-bridge 0.2.0
LLM integration layer for kore-mind. Runtime-agnostic cognitive bridge.
Requires Python: >=3.10
Keywords: ai, bridge, cognitive, identity, llm, memory

# kore-bridge

LLM integration layer for [kore-mind](https://github.com/iafiscal1212/kore-mind). Runtime-agnostic cognitive bridge.

## Install

```bash
pip install kore-bridge                # core (zero deps beyond kore-mind)
pip install kore-bridge[openai]        # + OpenAI
pip install kore-bridge[anthropic]     # + Anthropic
pip install kore-bridge[all]           # everything
```

## Quick start (Ollama — 100% local, zero API keys)

```bash
ollama pull llama3.2
```

```python
from kore_mind import Mind
from kore_bridge import Bridge, OllamaProvider

mind = Mind("agent.db")
llm = OllamaProvider(model="llama3.2")  # local, free, private
bridge = Bridge(mind=mind, llm=llm)

# Think with context (auto-remembers)
response = bridge.think("Help me with my proof", user="carlos")

# Observe something
bridge.observe("User prefers concise answers")

# Reflect: LLM generates emergent identity from memories
identity = bridge.reflect()
print(identity.summary)
```

## Providers

```python
# Ollama (local, recommended for OSS)
from kore_bridge import OllamaProvider
llm = OllamaProvider(model="llama3.2")

# OpenAI
from kore_bridge.providers import OpenAIProvider
llm = OpenAIProvider(model="gpt-4o-mini")

# Anthropic
from kore_bridge.providers import AnthropicProvider
llm = AnthropicProvider(model="claude-sonnet-4-5-20250929")

# Any callable
from kore_bridge import CallableLLM
llm = CallableLLM(lambda msgs: my_custom_api(msgs))
```

## Demo

```bash
python examples/demo_llm.py              # uses llama3.2
python examples/demo_llm.py mistral      # uses mistral
```

## License

MIT
kore-mind 0.2.0
Persistent memory + emergent identity engine for any LLM
Requires Python: >=3.10
Keywords: ai, cognitive, identity, llm, memory

# kore-mind

Persistent memory + emergent identity engine for any LLM.

**One file = one mind.** SQLite-based. Zero config. Runtime-agnostic.

## Install

```bash
pip install kore-mind
```

## Usage

```python
from kore_mind import Mind

mind = Mind("agent.db")

# Register experiences
mind.experience("User works on complexity theory proofs")
mind.experience("User prefers direct, concise answers")

# Recall relevant memories
memories = mind.recall("proof techniques")

# Reflect: decay old memories, consolidate, update identity
identity = mind.reflect()
print(identity.summary)

# Forget: explicit pruning
mind.forget(threshold=0.1)
```

## Core concepts

- **Memory has a lifecycle**: salience decays over time. Unused memories fade. Accessed memories strengthen.
- **Identity is emergent**: not configured, but computed from accumulated memories.
- **reflect()** is the key operation: decay + consolidation + identity update.

## API (5 methods)

| Method | Description |
|--------|-------------|
| `experience(text)` | Something happened. Record it. |
| `recall(query)` | What's relevant now? |
| `reflect(fn)` | Consolidate. Decay. Evolve. |
| `identity()` | Who am I now? |
| `forget(threshold)` | Explicit pruning. |

## License

MIT
razin 1.3.2
Static Analysis for LLM Agent Skills
Requires Python: >=3.12

<h1 align="center">Razin - Static analysis for LLM agent skills</h1>

<p align="center">
  <img src="https://github.com/user-attachments/assets/33c42667-0fff-4eac-a2d1-0f6d10441245" alt="razin" width="300" height="300" />
</p>

Razin is a local scanner for `SKILL.md`-defined agent skills.
It performs static analysis only (no execution) and writes deterministic findings.

## Table of contents

- [Documentation](#documentation)
- [Requirements](#requirements)
- [Install](#install)
- [Quick start](#quick-start)
  - [Common CI gates](#common-ci-gates)
  - [Output formats](#output-formats)
- [Local development](#local-development)
- [Where to read more](#where-to-read-more)
- [Contributing](#contributing)
- [Security](#security)
- [License](#license)

## Documentation

Full documentation lives at:

- https://theinfosecguy.github.io/razin/

Canonical docs source in this repository:

- `docs/`

Use this README for quick start only.

## Requirements

- Python `3.12+`

## Install

With Homebrew (if formula is in Homebrew core):

```bash
brew install razin
razin --help
```

With Homebrew tap (if core formula is not merged yet):

```bash
brew tap theinfosecguy/homebrew-tap
brew install razin
razin --help
```

With PyPI:

```bash
pip install razin
razin --help
```

## Quick start

Run a scan:

```bash
razin scan -r . -o output/
```

Validate config:

```bash
razin validate-config -r .
```

### Common CI gates

```bash
# Fail if any high-severity finding exists
razin scan -r . --fail-on high --no-stdout

# Fail if aggregate score is 70 or above
razin scan -r . --fail-on-score 70 --no-stdout
```

### Output formats

```bash
# Default per-skill JSON reports
razin scan -r . -o output/ --output-format json

# Add CSV + SARIF exports
razin scan -r . -o output/ --output-format json,csv,sarif
```

## Local development

```bash
uv sync --dev
uv run pytest -q
uv run ruff check src tests
uv run mypy src tests
```

Docs preview and checks:

```bash
uv sync --group docs
uv run mkdocs serve
uv run mkdocs build --strict
uv run mdformat --check README.md docs
```

## Where to read more

- [Getting started](https://theinfosecguy.github.io/razin/getting-started/)
- [CLI reference](https://theinfosecguy.github.io/razin/cli-reference/)
- [Configuration](https://theinfosecguy.github.io/razin/configuration/)
- [Detectors](https://theinfosecguy.github.io/razin/detectors/)
- [Output formats](https://theinfosecguy.github.io/razin/output-formats/)
- [Docker workflow](https://theinfosecguy.github.io/razin/docker/)
- [CI and exit codes](https://theinfosecguy.github.io/razin/ci-and-exit-codes/)
- [Troubleshooting](https://theinfosecguy.github.io/razin/troubleshooting/)

## Contributing

See [CONTRIBUTING.md](CONTRIBUTING.md).

## Security

See [SECURITY.md](SECURITY.md).

## License

[MIT](LICENSE)
df2onehot 1.2.1
Python package df2onehot is to convert a pandas dataframe into a stuctured dataframe.
Requires Python: >=3
Keywords: Python, one-hot encoding, preprocessing, structuring, encoding, categorical encoding, df2onehot, dataframe encoding, feature engineering, machine learning, data transformation, dummy variables, pandas, scikit-learn, data preprocessing

# df2onehot

[![Python](https://img.shields.io/pypi/pyversions/df2onehot)](https://img.shields.io/pypi/pyversions/df2onehot)
[![PyPI Version](https://img.shields.io/pypi/v/df2onehot)](https://pypi.org/project/df2onehot/)
[![License](https://img.shields.io/badge/license-MIT-green.svg)](https://github.com/erdogant/df2onehot/blob/master/LICENSE)
[![Downloads](https://pepy.tech/badge/df2onehot/month)](https://pepy.tech/project/df2onehot/month)
[![Downloads](https://pepy.tech/badge/df2onehot)](https://pepy.tech/project/df2onehot)
[![DOI](https://zenodo.org/badge/245003302.svg)](https://zenodo.org/badge/latestdoi/245003302)
[![Sphinx](https://img.shields.io/badge/Sphinx-Docs-Green)](https://erdogant.github.io/df2onehot/)
<!---[![BuyMeCoffee](https://img.shields.io/badge/buymea-coffee-yellow.svg)](https://www.buymeacoffee.com/erdogant)-->
<!---[![Coffee](https://img.shields.io/badge/coffee-black-grey.svg)](https://erdogant.github.io/donate/?currency=USD&amount=5)-->

``df2onehot`` is a Python package to convert unstructured DataFrames into structured dataframes, such as one-hot dense arrays.

# 
**⭐️ Star this repo if you like it ⭐️**
#

#### Install df2onehot from PyPI

```bash
pip install df2onehot
```

#### Import df2onehot package

```python
from df2onehot import df2onehot
```
# 


### [Documentation pages](https://erdogant.github.io/df2onehot/)

On the [documentation pages](https://erdogant.github.io/df2onehot/) you can find detailed information about the working of the ``df2onehot`` with many examples. 

<hr> 

### Examples

```python
results = df2onehot(df)
```

```python
# Force features (int or float) to be numeric if unique non-zero values are above percentage.
out = df2onehot(df, perc_min_num=0.8)
```

```python
# Remove categorical features for which less then 2 values exists.
out = df2onehot(df, y_min=2)
```

```python
# Combine two rules above.
out = df2onehot(df, y_min=2, perc_min_num=0.8)
```


# 
* [Example: Process Mixed dataset](https://erdogant.github.io/df2onehot/pages/html/Examples.html#)
# 
* [Example: Extracting nested columns](https://erdogant.github.io/df2onehot/pages/html/Examples.html#extracting-nested-columns)
# 
* [Example: Setting custom dtypes](https://erdogant.github.io/df2onehot/pages/html/Examples.html#custom-dtypes)
#

<hr>

#### Maintainers
* Erdogan Taskesen, github: [erdogant](https://github.com/erdogant)
* Contributions are welcome.
* If you wish to buy me a <a href="https://www.buymeacoffee.com/erdogant">Coffee</a> for this work, it is very appreciated :)
nexttoken 0.3.0
NextToken SDK - Simple client for the NextToken APIs and Gateway
Requires Python: >=3.8

# NextToken Python SDK

Simple Python client for the NextToken Gateway - an OpenAI-compatible LLM proxy.

## Installation

```bash
pip install nexttoken
```

## Quick Start

```python
from nexttoken import NextToken

# Initialize with your API key
client = NextToken(api_key="your-api-key")

# Use like the OpenAI SDK
response = client.chat.completions.create(
    model="gpt-4o",  # or "claude-3-5-sonnet", "gemini-2.5-flash"
    messages=[
        {"role": "user", "content": "Hello!"}
    ]
)

print(response.choices[0].message.content)
```

## Available Models

- OpenAI models
- Anthropic models
- Gemini models
- Openrouter models

## Embeddings

```python
from nexttoken import NextToken

client = NextToken(api_key="your-api-key")

response = client.embeddings.create(
    model="text-embedding-3-small",
    input="Your text to embed"
)

print(response.data[0].embedding)
```

## Integrations

Connect and use third-party services (Gmail, Slack, etc.) through your NextToken account.

```python
from nexttoken import NextToken

client = NextToken(api_key="your-api-key")

# List connected integrations
integrations = client.integrations.list()
print(integrations)

# List available actions for an app
actions = client.integrations.list_actions("gmail")
print(actions)

# Invoke a function
result = client.integrations.invoke(
    app="gmail",
    function_key="gmail-send-email",
    args={
        "to": "user@example.com",
        "subject": "Hello",
        "body": "Hello from NextToken!"
    }
)
print(result)
```

## Web Search

Search the web programmatically using NextToken's search API.

```python
from nexttoken import NextToken

client = NextToken(api_key="your-api-key")

# Basic search
results = client.search.query("latest AI developments")
for r in results:
    print(r["title"], r["url"])

# With domain filtering
results = client.search.query(
    "machine learning papers",
    num_results=10,
    include_domains=["arxiv.org", "nature.com"]
)
```

## Get Your API Key

Sign up at [nexttoken.co](https://nexttoken.co) and get your API key from Settings.

## License

MIT
pluto-ml-nightly 0.0.7.dev20260221105432
Pluto ML - Machine Learning Operations Framework
Requires Python: <4.0,>=3.10

[![pypi](https://img.shields.io/pypi/v/pluto-ml)](https://pypi.org/project/pluto-ml/)

**Pluto** is an experiment tracking platform. It provides [self-hostable superior experimental tracking capabilities and lifecycle management for training ML models](https://docs.trainy.ai/pluto). To take an interactive look, [try out our demo environment](https://demo.pluto.trainy.ai/o/dev-org) or [get an account with us today](https://pluto.trainy.ai/auth/sign-up)!

## See it in action

https://github.com/user-attachments/assets/6aff6448-00b6-41f2-adf4-4b7aa853ede6

## 🚀 Getting Started

Install the `pluto-ml` sdk

```bash
pip install -Uq "pluto-ml[full]"
```

```python
import pluto

pluto.init(project="hello-world")
pluto.log({"e": 2.718})
pluto.finish()
```

- Self-host your very own **Pluto** instance using the [Pluto Server](https://github.com/Trainy-ai/pluto-server)

You may also learn more about **Pluto** by checking out our [documentation](https://docs.trainy.ai/pluto).

<!-- You can try everything out in our [introductory tutorial](https://colab.research.google.com/github/Trainy-ai/pluto/blob/main/examples/intro.ipynb) and [torch tutorial](https://colab.research.google.com/github/Trainy-ai/pluto/blob/main/examples/torch.ipynb). -->

## Migration

### Neptune

Want to move your run data from Neptune to Pluto. Checkout the official docs from the Neptune transition hub [here](https://docs.neptune.ai/transition_hub/migration/to_pluto).

Before committing to Pluto, you want to see if there's parity between your Neptune and Pluto views? See our compatibility module documented [here](https://docs.trainy.ai/pluto/neptune-migration). Log to both Neptune and Pluto with a single import statement and no code changes.

## 🛠️ Development Setup

Want to contribute? Here's the quickest way to get the local toolchain (including the linters used in CI) running:

```bash
git clone https://github.com/Trainy-ai/pluto.git
cd pluto
python -m venv .venv && source .venv/bin/activate   # or use your preferred environment manager
python -m pip install --upgrade pip
pip install -e ".[full]"
```

Linting commands (mirrors `.github/workflows/lint.yml`):

```bash
bash format.sh
```

Run these locally before sending a PR to match the automation that checks on every push and pull request.

## 🫡 Vision

**Pluto** is a platform built for and by ML engineers, supported by [our community](https://discord.com/invite/HQUBJSVgAP)! We were tired of the current state of the art in ML observability tools, and this tool was born to help mitigate the inefficiencies - specifically, we hope to better inform you about your model performance and training runs; and actually **save you**, instead of charging you, for your precious compute time!

🌟 Be sure to star our repos if they help you ~
trainy-policy-nightly 0.1.0.dev20260221105358
Trainy Skypilot Policy
Requires Python: <4.0,>=3.9

# Trainy Skypilot Policy

This is a package that defines the Skypilot policies necessary for running on Trainy clusters. The purpose of the policy is to 

- mutate tasks to add the necessary labels/annotations (kueue, networking, etc.) per cloud provider
- set the available k8s clusters to be those that are visible via tailscale in the allowed k8s cluster contexts

For users, they set in `~/.sky/config.yaml`

```bash
admin_policy: trainy.policy.DynamicKubernetesContextsUpdatePolicy
```

and install
```bash
pip install "trainy-skypilot-nightly[kubernetes]"
pip install trainy-policy-nightly
```

[Skypilot Admin Policies](https://skypilot.readthedocs.io/en/latest/cloud-setup/policy.html)
legend-pygeom-tools 0.3.1
Python tools to handle Monte Carlo simulation geometry
Requires Python: >=3.10

# legend-pygeom-tools

[![PyPI](https://img.shields.io/pypi/v/legend-pygeom-tools?logo=pypi)](https://pypi.org/project/legend-pygeom-tools/)
[![conda-forge](https://img.shields.io/conda/vn/conda-forge/legend-pygeom-tools.svg)](https://anaconda.org/conda-forge/legend-pygeom-tools)
![GitHub tag (latest by date)](https://img.shields.io/github/v/tag/legend-exp/legend-pygeom-tools?logo=git)
[![GitHub Workflow Status](https://img.shields.io/github/checks-status/legend-exp/legend-pygeom-tools/main?label=main%20branch&logo=github)](https://github.com/legend-exp/legend-pygeom-tools/actions)
[![pre-commit](https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white)](https://github.com/pre-commit/pre-commit)
[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
[![Codecov](https://img.shields.io/codecov/c/github/legend-exp/legend-pygeom-tools?logo=codecov)](https://app.codecov.io/gh/legend-exp/legend-pygeom-tools)
![GitHub issues](https://img.shields.io/github/issues/legend-exp/legend-pygeom-tools?logo=github)
![GitHub pull requests](https://img.shields.io/github/issues-pr/legend-exp/legend-pygeom-tools?logo=github)
![License](https://img.shields.io/github/license/legend-exp/legend-pygeom-tools)
[![Read the Docs](https://img.shields.io/readthedocs/legend-pygeom-tools?logo=readthedocs)](https://legend-pygeom-tools.readthedocs.io)

Python tools to handle Monte Carlo simulation geometry using
[pyg4ometry](https://pypi.org/project/pyg4ometry/).