semvec/pypi-packages huggingface dataset:
cfenv-kv-sync-python 0.1.0b1
Python SDK for cfenv Cloudflare KV environment sync and hot updates
Requires Python: >=3.9

# cfenv Python SDK

Python SDK for reading `cfenv` flat-mode environment values from Cloudflare KV and applying hot updates.

## Install

```bash
pip install cfenv-kv-sync-python
```

For local development:

```bash
pip install -e /path/to/cloudflare-kv-env/packages/python-sdk
```

Recommended with `uv`:

```bash
cd /path/to/cloudflare-kv-env/packages/python-sdk
uv sync
uv run python -m unittest discover -s tests -v
```

## Basic Usage

```python
from cfenv_sdk import CfenvClient

client = CfenvClient(
    account_id="...",
    api_token="...",
    namespace_id="...",
    project="playheads",
    environment="production",
)

snapshot = client.fetch_flat_env()
print(snapshot.entries)
```

## Export

```python
dotenv_text = client.export_dotenv()
json_text = client.export_json()
```

## Hot Update

```python
from cfenv_sdk import CfenvClient

client = CfenvClient(
    account_id="...",
    api_token="...",
    namespace_id="...",
    project="playheads",
    environment="production",
)

def on_update(snapshot, reason):
    print("updated", reason, snapshot.metadata.updated_at, snapshot.metadata.entries_count)
    client.apply_to_process_env(overwrite=True)

def on_error(err):
    print("hot update error:", err)

watcher = client.create_hot_updater(
    on_update=on_update,
    on_error=on_error,
    interval_seconds=30,
    max_interval_seconds=300,
    bootstrap=True,
)
watcher.start()
```
iflow-mcp_kapeli-dash-mcp-server 1.0.0
MCP server for Dash, the macOS documentation browser
Requires Python: >=3.11

# mcp-server-dash

A Model Context Protocol (MCP) server that provides tools to interact with the [Dash](https://kapeli.com/dash) documentation browser API.

Dash 8 is required. You can download Dash 8 at https://blog.kapeli.com/dash-8.

<a href="https://glama.ai/mcp/servers/@Kapeli/dash-mcp-server">
  <img width="380" height="200" src="https://glama.ai/mcp/servers/@Kapeli/dash-mcp-server/badge" alt="Dash Server MCP server" />
</a>

## Overview

The Dash MCP server provides tools for accessing and searching documentation directly from Dash, the macOS documentation browser. MCP clients can:

- List installed docsets
- Search across docsets and code snippets
- Enable full-text search for specific docsets

### Notice

This is a work in progress. Any suggestions are welcome!

## Tools

1. **list_installed_docsets**
   - Lists all installed documentation sets in Dash
2. **search_documentation**
   - Searches across docsets and snippets
3. **enable_docset_fts**
   - Enables full-text search for a specific docset

## Requirements

- macOS (required for Dash app)
- [Dash](https://kapeli.com/dash) installed
- Python 3.11.4 or higher
- uv

## Configuration

### Using uvx

```bash
brew install uv
```

#### in `claude_desktop_config.json`

```json
{
  "mcpServers": {
      "dash-api": {
          "command": "uvx",
          "args": [
              "--from",
              "git+https://github.com/Kapeli/dash-mcp-server.git",
              "dash-mcp-server"
          ]
      }
  }
}
```

#### in `Claude Code`

```bash
claude mcp add dash-api -- uvx --from "git+https://github.com/Kapeli/dash-mcp-server.git" "dash-mcp-server"
```
iflow-mcp_torshepherd-compiler-explorer-mcp 0.1.2
MCP server allowing LLMs to interact remotely with compilers
Requires Python: >=3.11
Keywords: claude, compiler, explorer, llm, mcp

# Compiler Explorer MCP

A Model Context Protocol (MCP) server that connects LLMs to the Compiler Explorer API, enabling them to compile code, explore compiler features, and analyze optimizations across different compilers and languages.

## Example Questions

Here are some interesting questions you can ask your LLM using this MCP:

### Compiler Feature Exploration
- "What is the earliest version of GCC that supports the `#embed` directive?"
- "Show me how different versions of Clang handle C++20 modules"
- "What optimization flags are available in Clang 12 that weren't in Clang 11?"
- "Can you demonstrate how MSVC and GCC handle C++20 coroutines differently?"

### Optimization Analysis
- "What's the assembly difference between `-O2` and `-O3` for a simple recursive Fibonacci function in GCC 13?"
- "How does Clang's vectorization compare to GCC's for a basic matrix multiplication?"
- "Show me how different optimization levels affect tail-call optimization in this recursive function"
- "What's the impact of `-ffast-math` on this floating-point heavy computation?"

### Language Feature Support
- "Which C++20 features are supported in the latest versions of GCC, Clang, and MSVC?"
- "Show me how different compilers implement std::optional's memory layout"
- "Compare how GCC and Clang handle C++20's constexpr virtual functions"
- "Demonstrate the differences in how Intel and GCC compilers auto-vectorize SIMD operations"

### Assembly Deep Dives
- "What's the most efficient way to implement a population count in x86 assembly across different CPU architectures?"
- "Show me how different compilers optimize a simple string reverse function at -O3"
- "Compare the assembly output of a virtual function call vs a normal function call"
- "How do different compilers implement std::variant's type switching in assembly?"

### Cross-Language Comparison
- "Compare the generated assembly for the same algorithm in C++, Rust, and Go"
- "How do exception handling mechanisms differ between C++ and Rust in terms of generated code?"
- "Show me the overhead of Rust's bounds checking compared to unchecked C++ array access"
- "Compare how C++ and D implement RAII in terms of generated assembly"

### Performance Investigation
- "What's the assembly-level difference between using std::sort and a hand-written quicksort?"
- "Show me how different string concatenation methods compare in terms of generated instructions"
- "Compare the efficiency of std::map vs std::unordered_map operations in assembly"
- "How do different smart pointer implementations affect inlining and code size?"
session-info2 0.4
Print versions of imported packages.
Requires Python: >=3.10
Keywords: jupyter, session-info

# session-info2

[![PyPI - Version](https://img.shields.io/pypi/v/session-info2.svg)](https://pypi.org/project/session-info2)
[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/session-info2.svg)](https://pypi.org/project/session-info2)
[![Docs](https://readthedocs.org/projects/session-info2/badge/)](https://session-info2.readthedocs.io/)

## Installation

```console
pip install session-info2
```

## Usage

See <https://session-info2.readthedocs.io/>
In short:

Use the `session-info` CLI program (see `session-info -h`) or use it programmatically:

Import whayever your script/notebook relies on,
as well as [session_info][].

```pycon
>>> httpx
>>> from session_info2 import session_info
```

Some usage examples (see links above for more).
Minimal output:

```pycon
>>> session_info(os=False)
httpx	0.28.1
----	----
Python	3.12.5 (main, Aug  6 2024, 19:08:49) [Clang 16.0.6 ]
Updated	2024-12-20 14:22
```

With indirect dependencies:

```pycon
>>> session_info(dependencies=True)
httpx	0.28.1
----	----
anyio	4.7.0
h11	0.14.0
sniffio	1.3.1
session-info2	0.1.2
certifi	2024.12.14
httpcore	1.0.7
appdirs	1.4.4
----	----
Python	3.12.5 (main, Aug  6 2024, 19:08:49) [Clang 16.0.6 ]
OS	macOS-15.1.1-arm64-arm-64bit
Updated	2024-12-20 14:24
```

[session_info]: https://session-info2.readthedocs.io/en/stable/api.html#session_info2.session_info
shepherd-data 2026.2.4
Programming- and CLI-Interface for the h5-dataformat of the Shepherd-Testbed
Requires Python: >=3.10
Keywords: testbed, beaglebone, pru, batteryless, energyharvesting, solar

# Shepherd-Data-Tool

[![PyPIVersion](https://img.shields.io/pypi/v/shepherd_data.svg)](https://pypi.org/project/shepherd_data)
[![image](https://img.shields.io/pypi/pyversions/shepherd_data.svg)](https://pypi.python.org/pypi/shepherd-data)
[![QA-Tests](https://github.com/nes-lab/shepherd-tools/actions/workflows/quality_assurance.yaml/badge.svg)](https://github.com/nes-lab/shepherd-tools/actions/workflows/quality_assurance.yaml)
[![CodeStyle](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)

**Main Documentation**: <https://nes-lab.github.io/shepherd>

**Source Code**: <https://github.com/nes-lab/shepherd-tools>

**Main Project**: <https://github.com/nes-lab/shepherd>

---

`shepherd-data` eases the handling of hdf5-recordings used by the [shepherd](https://github.com/nes-lab/shepherd)-testbed. Users can read, validate and create files and also extract, down-sample and plot information.

## Installation

### PIP - Online

```shell
pip3 install shepherd-data -U
```

For bleeding-edge-features or dev-work it is possible to install directly from GitHub-Sources (here `dev`-branch):

```Shell
pip install git+https://github.com/nes-lab/shepherd-tools.git@dev#subdirectory=shepherd_data -U
```

## More

Please consult the [official documentation](https://nes-lab.github.io/shepherd) for more, it covers:

- general context
- command-line interface
- programming interface
iflow-mcp_brevdev-brev-mcp 0.1.0
A MCP server project
Requires Python: >=3.10

# Brev MCP server

This is a MCP server implementation for Brev.

## Configuration

The MCP server uses the Brev CLI's API access token and currently set org. 

Follow the [Brev documentation](https://www.brev.dev/docs/reference/brev-cli) to download the CLI and login if you haven't already.

If you want to switch your Brev org, run `brev set <org-name>`

The CLI access token expires every hour. If you have any 403 errors, simply run `brev ls` to refresh the access token.

## Quickstart

### Setup repository locally

`git clone git@github.com:brevdev/brev-mcp.git`

### Install uv

Follow the [uv installation guide](https://docs.astral.sh/uv/getting-started/installation/)

#### Claude Desktop

On MacOS: `~/Library/Application\ Support/Claude/claude_desktop_config.json`
On Windows: `%APPDATA%/Claude/claude_desktop_config.json`

Add the following to your `claude_desktop_config.json`:

<details>
  <summary>Development/Unpublished Servers Configuration</summary>

  ```json
  "mcpServers": {
    "brev_mcp": {
      "command": "uv",
      "args": [
        "--directory",
        "<path-to-repo>",
        "run",
        "brev-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/tmontfort/Brev/repos/brev_mcp run brev-mcp
```


Upon launching, the Inspector will display a URL that you can access in your browser to begin debugging.
elizaos-plugin-elevenlabs 2.0.0a4
High-quality text-to-speech and speech-to-text plugin for ElizaOS using ElevenLabs API
Requires Python: >=3.10
Keywords: ai, elevenlabs, elizaos, plugin, speech-to-text, stt, text-to-speech, transcription, tts, voice-synthesis

# ElevenLabs Plugin for ElizaOS (Python)

High-quality text-to-speech (TTS) and speech-to-text (STT) plugin for ElizaOS using the ElevenLabs API.

## Installation

```bash
pip install eliza-plugin-elevenlabs
```

## Features

- **Text-to-Speech (TTS)**: High-quality voice synthesis with multiple voice models
- **Speech-to-Text (STT)**: Accurate transcription with Scribe v1 model
- **Speaker Diarization**: Identify up to 32 different speakers
- **Multi-language Support**: 99 languages for STT
- **Audio Event Detection**: Detect laughter, applause, and other audio events
- **Streaming Support**: Efficient memory usage with streaming audio output

## Usage

```python
from eliza_plugin_elevenlabs import elevenlabs_plugin, ElevenLabsService

# Create the service
service = ElevenLabsService(api_key="your-api-key")

# Text-to-speech
audio_stream = await service.text_to_speech("Hello, world!")

# Speech-to-text
transcript = await service.speech_to_text(audio_file)
```

## Configuration

| Environment Variable | Description | Default |
|---------------------|-------------|---------|
| `ELEVENLABS_API_KEY` | ElevenLabs API key | Required |
| `ELEVENLABS_VOICE_ID` | Voice ID for TTS | `EXAVITQu4vr4xnSDxMaL` |
| `ELEVENLABS_MODEL_ID` | TTS model ID | `eleven_multilingual_v2` |
| `ELEVENLABS_VOICE_STABILITY` | Voice stability (0-1) | `0.5` |
| `ELEVENLABS_VOICE_SIMILARITY_BOOST` | Similarity boost (0-1) | `0.75` |
| `ELEVENLABS_OUTPUT_FORMAT` | Audio output format | `mp3_44100_128` |
| `ELEVENLABS_STT_MODEL_ID` | STT model ID | `scribe_v1` |
| `ELEVENLABS_STT_DIARIZE` | Enable speaker diarization | `false` |

## License

MIT
elizaos-plugin-discord 2.0.0a4
Discord plugin for elizaOS - Python implementation
Requires Python: >=3.11
Keywords: agent, ai, bot, discord, elizaos

# elizaOS Discord Plugin (Python)

Python implementation of the Discord plugin for elizaOS agents.

## Installation

```bash
pip install elizaos-plugin-discord
```

For voice support:

```bash
pip install elizaos-plugin-discord[voice]
```

## Quick Start

```python
import asyncio
from elizaos_plugin_discord import DiscordConfig, DiscordService

async def main():
    # Load config from environment
    config = DiscordConfig.from_env()

    # Create and start the service
    service = DiscordService(config)

    # Set up event handler
    @service.on_message
    async def handle_message(message):
        print(f"Received: {message.content}")

    # Start the bot
    await service.start()

asyncio.run(main())
```

## Configuration

Set the following environment variables:

| Variable                                  | Required | Description                                     |
| ----------------------------------------- | -------- | ----------------------------------------------- |
| `DISCORD_API_TOKEN`                       | Yes      | Bot token from Discord Developer Portal         |
| `DISCORD_APPLICATION_ID`                  | Yes      | Application ID from Discord Developer Portal    |
| `CHANNEL_IDS`                             | No       | Comma-separated list of channel IDs to monitor  |
| `DISCORD_SHOULD_IGNORE_BOT_MESSAGES`      | No       | Ignore messages from other bots (default: true) |
| `DISCORD_SHOULD_IGNORE_DIRECT_MESSAGES`   | No       | Ignore DMs (default: false)                     |
| `DISCORD_SHOULD_RESPOND_ONLY_TO_MENTIONS` | No       | Only respond when mentioned (default: false)    |

## Actions

- `send_message` - Send a message to a channel
- `send_dm` - Send a direct message to a user
- `add_reaction` - Add a reaction to a message

## Providers

- `channel_state` - Current channel information
- `voice_state` - Voice channel state
- `guild_info` - Server/guild information

## Development

```bash
# Install dev dependencies
pip install -e ".[dev]"

# Run tests
pytest

# Type checking
mypy elizaos_plugin_discord

# Linting
ruff check elizaos_plugin_discord
```

## License

MIT
elizaos-plugin-directives 2.0.0a4
elizaOS Directives Plugin - parse and manage agent directives
Requires Python: >=3.11
Keywords: agents, ai, directives, elizaos, parsing

# elizaos-plugin-directives

elizaOS Directives Plugin - parse and manage agent directives

## Installation

```bash
pip install elizaos-plugin-directives
```

## Part of elizaOS

This is a Python plugin for the [elizaOS](https://github.com/elizaos/eliza) AI agent framework.

## License

MIT
elizaos-plugin-copilot-proxy 2.0.0a4
elizaOS Copilot Proxy Plugin - OpenAI-compatible local proxy for VS Code Copilot
Requires Python: >=3.11
Keywords: agents, ai, copilot, elizaos, llm, openai, proxy

# elizaOS Copilot Proxy Plugin (Python)

Python implementation of the Copilot Proxy model provider plugin for elizaOS.

## Features

- OpenAI-compatible API client for Copilot Proxy
- Support for text generation (small and large models)
- JSON object generation with automatic parsing
- Health check functionality
- Configurable timeouts and model parameters
- Async/await support

## Installation

```bash
pip install elizaos-plugin-copilot-proxy
```

## Usage

```python
import asyncio
from elizaos_plugin_copilot_proxy import CopilotProxyPlugin

async def main():
    # Create plugin (uses environment variables or defaults)
    plugin = CopilotProxyPlugin()
    
    async with plugin:
        # Generate text
        response = await plugin.generate_text_large("What is 2+2?")
        print(response)
        
        # Generate JSON object
        obj = await plugin.generate_object_small("Create a JSON object with a greeting")
        print(obj)

asyncio.run(main())
```

## Environment Variables

- `COPILOT_PROXY_BASE_URL` - Base URL for the proxy server (default: `http://localhost:3000/v1`)
- `COPILOT_PROXY_ENABLED` - Enable/disable the plugin (default: `true`)
- `COPILOT_PROXY_SMALL_MODEL` - Small model ID (default: `gpt-5-mini`)
- `COPILOT_PROXY_LARGE_MODEL` - Large model ID (default: `gpt-5.1`)
- `COPILOT_PROXY_TIMEOUT_SECONDS` - Request timeout (default: `120`)
- `COPILOT_PROXY_MAX_TOKENS` - Maximum tokens (default: `8192`)
- `COPILOT_PROXY_CONTEXT_WINDOW` - Context window size (default: `128000`)

## License

MIT
elizaos-plugin-computeruse 2.0.0a4
Computer automation plugin for ElizaOS - enables AI agents to control the local machine (when supported) or a ComputerUse MCP server
Requires Python: >=3.10
Keywords: automation, computeruse, desktop, elizaos, mcp, plugin

# elizaos-plugin-computeruse (Python)

Python plugin wrapper for ComputerUse.

- Local mode (Windows, macOS, Linux): uses the `computeruse` Python extension module (from `computeruse-py`). macOS requires Accessibility permissions; Linux requires AT-SPI2.
- MCP mode: spawns an MCP server via stdio (default: `npx -y computeruse-mcp-agent@latest`).

## Actions / arguments

- `COMPUTERUSE_CLICK`: requires `selector` and (in MCP mode) a `process` scope. You can pass `process` explicitly or prefix the selector with `process:<name> >> ...`.
- `COMPUTERUSE_TYPE`: same scoping rules as click.
- `COMPUTERUSE_GET_WINDOW_TREE`: requires `process` (and optional `title`, `maxDepth`).
elizaos-plugin-bluesky 2.0.0a4
elizaOS BlueSky Plugin - AT Protocol client for social interactions
Requires Python: >=3.11
Keywords: agents, ai, atprotocol, bluesky, elizaos, social

# elizaOS BlueSky Plugin (Python)

Python implementation of the BlueSky plugin for elizaOS using the AT Protocol.

## Installation

```bash
pip install elizaos-plugin-bluesky
```

## Usage

```python
from elizaos_plugin_bluesky import BlueSkyClient, BlueSkyConfig

# Create configuration
config = BlueSkyConfig(
    handle="your-handle.bsky.social",
    password="your-app-password",
)

# Or load from environment
config = BlueSkyConfig.from_env()

# Create client
async with BlueSkyClient(config) as client:
    # Authenticate
    await client.authenticate()

    # Create a post
    from elizaos_plugin_bluesky import CreatePostRequest, CreatePostContent

    request = CreatePostRequest(
        content=CreatePostContent(text="Hello from Python!")
    )
    post = await client.send_post(request)
    print(f"Created post: {post.uri}")

    # Get timeline
    from elizaos_plugin_bluesky import TimelineRequest

    timeline = await client.get_timeline(TimelineRequest(limit=10))
    for item in timeline.feed:
        print(f"@{item.post.author.handle}: {item.post.record.text}")
```

## Environment Variables

Required:

- `BLUESKY_HANDLE`: Your BlueSky handle
- `BLUESKY_PASSWORD`: Your app password

Optional:

- `BLUESKY_SERVICE`: BlueSky service URL (default: https://bsky.social)
- `BLUESKY_DRY_RUN`: Enable dry run mode (default: false)
- `BLUESKY_POLL_INTERVAL`: Notification polling interval in seconds (default: 60)
- `BLUESKY_ENABLE_POSTING`: Enable automated posting (default: true)
- `BLUESKY_ENABLE_DMS`: Enable direct messaging (default: true)

## Development

```bash
# Install dev dependencies
pip install -e ".[dev]"

# Run tests
pytest

# Type checking
mypy elizaos_plugin_bluesky

# Linting
ruff check .
ruff format .
```

## License

MIT
elizaos-plugin-bluebubbles 2.0.0a4
BlueBubbles iMessage bridge plugin for ElizaOS agents
Requires Python: >=3.10
Keywords: apple, bluebubbles, elizaos, imessage, plugin

# @elizaos/plugin-bluebubbles (Python)

Python implementation of the BlueBubbles plugin for ElizaOS.

## Installation

```bash
pip install elizaos-plugin-bluebubbles
```

## Usage

This plugin provides BlueBubbles iMessage integration capabilities for ElizaOS agents.
elizaos-plugin-auto-trader 2.0.0a4
elizaOS Auto Trader Plugin - automated trading strategies
Requires Python: >=3.11
Keywords: ai, backtesting, elizaos, strategies, trading

# elizaos-plugin-auto-trader

elizaOS Auto Trader Plugin - automated trading strategies

## Installation

```bash
pip install elizaos-plugin-auto-trader
```

## Part of elizaOS

This is a Python plugin for the [elizaOS](https://github.com/elizaos/eliza) AI agent framework.

## License

MIT
elizaos-plugin-agent-skills 2.0.0a4
Agent Skills plugin for elizaOS - implement the Agent Skills specification with progressive disclosure
Requires Python: >=3.10
Keywords: agent-skills, agents, clawhub, elizaos, otto, plugin, skills

# Agent Skills Plugin for elizaOS (Python)

Implements the Agent Skills specification with:
- Spec-compliant SKILL.md parsing and validation
- Progressive disclosure (metadata → instructions → resources)
- ClawHub registry integration
- Otto metadata compatibility
- Dual storage modes (memory/filesystem)

## Installation

```bash
pip install elizaos-plugin-agent-skills
```

For development:

```bash
pip install -e ".[dev]"
```

## Usage

### Basic Parsing

```python
from elizaos_plugin_agent_skills import parse_frontmatter, validate_frontmatter

content = """---
name: my-skill
description: A helpful skill for doing things
---
# My Skill

Instructions here.
"""

result = parse_frontmatter(content)
frontmatter = result["frontmatter"]
body = result["body"]

# Validate
validation = validate_frontmatter(frontmatter, "my-skill")
if validation["valid"]:
    print(f"Skill: {frontmatter['name']}")
```

### Storage (Memory vs Filesystem)

```python
from elizaos_plugin_agent_skills import (
    MemorySkillStore,
    FileSystemSkillStore,
    load_skill_from_storage,
    install_from_github,
)

# Memory storage (browser/virtual FS)
store = MemorySkillStore("/virtual/skills")
await store.initialize()

# Load from content
await store.load_from_content("my-skill", skill_md_content)

# Or from GitHub
skill = await install_from_github(store, "owner/repo", path="skills/my-skill")

# Load skill
skill = await load_skill_from_storage(store, "my-skill")
print(f"Loaded: {skill['name']}")
```

### Generate XML for Agent Prompts

```python
from elizaos_plugin_agent_skills import generate_skills_xml

skills = [
    {"name": "skill-one", "description": "First skill", "location": "/path/to/skill"},
    {"name": "skill-two", "description": "Second skill", "location": "/path/to/skill"},
]

xml = generate_skills_xml(skills, include_location=True)
print(xml)
```

## Testing

```bash
# Install dev dependencies
pip install -e ".[dev]"

# Run tests
pytest

# With Anthropic integration tests
ANTHROPIC_API_KEY=your-key pytest
```

## Specification

See: https://agentskills.io