semvec/pypi-packages huggingface dataset:
iflow-mcp_dshvadskiy-garmin-mcp 0.1.0
Garmin Connect MCP Server
Requires Python: >=3.11

# Garmin Connect MCP Server

This project provides a server for interacting with the Garmin Connect API. It allows users to manage their Garmin data, including workouts, health metrics, and more.

## Getting Started

### Prerequisites

- Python 3.x
- Required Python packages (install via `uv sync`)
- A Garmin Connect account
- Uses Python Garmin Connect Package to interact with Garmin Connect API: https://github.com/cyberjunky/python-garminconnect

### Environment Variables

Create a `.env` file in the root directory from the `.env_template` file with the following variables:

- `GARMIN_EMAIL`
- `GARMIN_PASSWORD`

## Generate token for Garmin Connect

```bash
python example.py
```

## Use MCP Inspector

```bash
mcp dev garmin_mcp_server.py
```

## Register MCP Server in Claude Desktop

```bash
mcp install garmin_mcp_server.py
```

### Running the Server
pvfalcondemo 2.0.1
Falcon Speaker Diarization engine demos
Requires Python: >=3.9
Keywords: Speaker Diarization, Speaker Identification, Voice Identification

# Falcon Speaker Diarization Demos

Made in Vancouver, Canada by [Picovoice](https://picovoice.ai)

## Falcon

Falcon is an on-device speaker diarization engine. Falcon is:

- Private; All voice processing runs locally.
- Cross-Platform:
  - Linux (x86_64), macOS (x86_64, arm64), Windows (x86_64, arm64)
  - Raspberry Pi (3, 4, 5)

## Compatibility

- Python 3.9+
- Runs on Linux (x86_64), macOS (x86_64, arm64), Windows (x86_64, arm64), and Raspberry Pi (3, 4, 5).

## Installation

```console
pip3 install pvfalcondemo
```

## AccessKey

Falcon requires a valid Picovoice `AccessKey` at initialization. `AccessKey` acts as your credentials when using Falcon SDKs.
You can get your `AccessKey` for free. Make sure to keep your `AccessKey` secret.
Signup or Login to [Picovoice Console](https://console.picovoice.ai/) to get your `AccessKey`.

## Usage

### File Demo

Run the following in the terminal:

```console
falcon_demo_file --access_key ${ACCESS_KEY} --wav_paths ${AUDIO_PATH}
```

Replace `${ACCESS_KEY}` with yours obtained from Picovoice Console and `${AUDIO_PATH}` with a path to an audio file.

### Microphone Demo

You need a working microphone connected to your machine for this demo. Run the following in the terminal:

```console
falcon_demo_mic --access_key ${ACCESS_KEY}
```

Replace `${ACCESS_KEY}` with yours obtained from Picovoice Console. Once running, the demo prints:

```console
>>> Press `ENTER` to start: 
```

Press `ENTER` key and wait for the following message in the terminal:

```console
>>> Recording ... Press `ENTER` to stop:
```

Now start recording and when done press `ENTER` key.
vision-agents-plugins-decart 0.3.6
Decart plugin for Vision Agents
Requires Python: >=3.10
Keywords: AI, agents, decart, voice agents

# Decart Plugin for Vision Agents

Decart integration for Vision Agents framework, enabling real-time video restyling capabilities.

It enables features such as:
- Real-time video transformation using generative AI models
- Dynamic style changing via prompts
- Seamless integration with Vision Agents video pipeline

## Installation

```bash
uv add vision-agents[decart]
```

## Usage

This example shows how to use the `RestylingProcessor` to transform a user's video feed in real-time.

```python
from vision_agents.core import User, Agent
from vision_agents.plugins import getstream, openai, decart

# Initialize the restyling processor
processor = decart.RestylingProcessor(
    initial_prompt="A cute animated movie with vibrant colours",
    model="mirage_v2"
)

agent = Agent(
    edge=getstream.Edge(),
    agent_user=User(name="Styled AI"),
    instructions="You are a helpful assistant.",
    llm=openai.LLM("gpt-4o-mini"),
    # Add the processor to the agent's pipeline
    processors=[processor],
)
```

### Dynamic Prompt Updates

You can register a function to update the style prompt dynamically based on the conversation:

```python
@llm.register_function(
    description="Change the video style prompt"
)
async def change_style(prompt: str) -> str:
    await processor.update_prompt(prompt)
    return f"Style changed to: {prompt}"
```

## Configuration

The plugin requires a Decart API key. You can provide it in two ways:

1. Set the environment variable `DECART_API_KEY`
2. Pass it directly to the constructor: `RestylingProcessor(api_key="...")`

## Links
- [Documentation](https://visionagents.ai/)
- [GitHub](https://github.com/GetStream/Vision-Agents)
vision-agents-plugins-pocket 0.3.6
Pocket TTS integration for Vision Agents - lightweight CPU-based text-to-speech
Requires Python: >=3.10
Keywords: AI, TTS, agents, kyutai, pocket-tts, text-to-speech, voice agents

# Pocket TTS Plugin

A lightweight Text-to-Speech (TTS) plugin for [Vision Agents](https://github.com/GetStream/Vision-Agents) powered by Kyutai's [Pocket TTS](https://huggingface.co/kyutai/pocket-tts) model. Runs efficiently on CPU with low latency (~200ms) and supports voice cloning.

## Features

- Runs on CPU - no GPU required
- Small model size (100M parameters)
- Low latency (~200ms to first audio)
- Voice cloning support
- Built-in voice selection

## Installation

```bash
uv add vision-agents[pocket]
```

## Usage

```python
from vision_agents.plugins import pocket

# Create TTS with default voice
tts = pocket.TTS()

# Or specify a built-in voice
tts = pocket.TTS(voice="marius")

# Or use a custom voice for cloning
tts = pocket.TTS(voice="path/to/your/voice.wav")
```

## Configuration

| Parameter | Description | Values |
|-----------|-------------|--------|
| `voice` | Built-in voice name or path to custom wav file | `"alba"` (default), `"marius"`, `"javert"`, `"jean"`, `"fantine"`, `"cosette"`, `"eponine"`, `"azelma"`, or custom path |

## Built-in Voices

- `alba` - Default voice
- `marius`
- `javert`
- `jean`
- `fantine`
- `cosette`
- `eponine`
- `azelma`

## Dependencies

- pocket-tts>=0.1.0
- PyTorch 2.5+
vision-agents-plugins-twilio 0.3.6
Twilio plugin for Vision Agents - Voice call integration with media streaming
Requires Python: >=3.10

# Twilio Plugin

Twilio plugin for Vision Agents enabling voice call integration with real-time audio streaming.

## Features

- **Media Streaming**: Bidirectional audio streaming via Twilio Media Streams
- **Call Registry**: Track active calls with metadata (caller info, timestamps)
- **Audio Conversion**: Automatic mulaw/PCM conversion for Twilio compatibility
- **WebSocket Management**: Handle Twilio WebSocket connections

## Installation

```bash
uv add vision-agents[twilio]
```

## Usage

```python
from vision_agents.plugins import twilio

# Create a call registry to track active calls
registry = twilio.CallRegistry()

# When receiving a voice webhook, register the call
call = registry.create(call_sid="CA123...", form_data={"From": "+1234567890", ...})

# Create a media stream for the WebSocket connection
stream = twilio.MediaStream(websocket)
await stream.accept()

# Associate stream with call
call.twilio_stream = stream

# Run the stream (blocks until call ends)
await stream.run()
```

## Components

### TwilioCall

Dataclass representing an active call session:

```python
@dataclass
class TwilioCall:
    call_sid: str
    form_data: dict[str, Any]  # All Twilio webhook data
    twilio_stream: Optional[TwilioMediaStream]
    stream_call: Optional[Any]  # Stream video call
    started_at: datetime
    ended_at: Optional[datetime]
    
    # Convenience properties
    from_number: str  # Caller's phone number
    to_number: str    # Called phone number
    call_status: str  # Current call status
```

### TwilioCallRegistry

In-memory registry for managing active calls:

```python
registry = twilio.CallRegistry()
registry.create(call_sid, form_data)  # Register new call
registry.get(call_sid)                 # Look up call
registry.remove(call_sid)              # Remove and mark ended
registry.list_active()                 # List active calls
```

### TwilioMediaStream

Manages Twilio Media Stream WebSocket connections:

```python
stream = twilio.MediaStream(websocket)
await stream.accept()

# Access the audio track for publishing
stream.audio_track  # AudioStreamTrack at 8kHz

# Send audio back to Twilio
await stream.send_audio(pcm_data)

# Run until stream ends
await stream.run()
```

## Audio Utilities

```python
from vision_agents.plugins.twilio import mulaw_to_pcm, pcm_to_mulaw, TWILIO_SAMPLE_RATE

# Convert Twilio mulaw to PCM
pcm = mulaw_to_pcm(mulaw_bytes)

# Convert PCM to Twilio mulaw
mulaw = pcm_to_mulaw(pcm_data)
```

## Configuration

| Parameter | Description | Default |
|-----------|-------------|---------|
| `TWILIO_SAMPLE_RATE` | Twilio audio sample rate | `8000` (8kHz) |

## Environment Variables

- `TWILIO_ACCOUNT_SID`: Your Twilio account SID
- `TWILIO_AUTH_TOKEN`: Your Twilio auth token

## Dependencies

- vision-agents
- twilio
- numpy
upsert-pandas 0.0.4
Upsert function in Pandas
Requires Python: >=3.11
Keywords: pandas, upsert

# _Upsert_ Pandas

[![Repo](https://img.shields.io/badge/GitHub-repo-blue?logo=github&logoColor=f5f5f5)](https://github.com/michelmetran/upsert-pandas)
[![PyPI - Version](https://img.shields.io/pypi/v/upsert-pandas?logo=pypi&label=PyPI&color=blue)](https://pypi.org/project/upsert-pandas/)<br>
[![Read the Docs](https://img.shields.io/readthedocs/upsert-pandas?logo=ReadTheDocs&label=Read%20The%20Docs)](https://upsert-pandas.readthedocs.io/)
[![Publish Python to PyPI](https://github.com/michelmetran/upsert-pandas/actions/workflows/publish-to-pypi-uv.yml/badge.svg)](https://github.com/michelmetran/upsert-pandas/actions/workflows/publish-to-pypi-uv.yml)

A função _Upsert_ é uma operação fundamental em bancos de dados e sistemas de gerenciamento de dados que combina as operações de _Update_ (Atualizar) e _Insert_ (Inserir) em uma única etapa atômica. O nome _Upsert_ é, literalmente, uma junção dos dois verbos.

<br>

---

## Objetivo da Função _Upsert_

O principal objetivo do _upsert_ é garantir que os dados de uma fonte de origem sejam sincronizados de forma eficiente com uma tabela de destino, sem gerar erros de duplicidade nas chaves primárias.

Ela funciona verificando a existência de um registro com base em uma Chave de Negócio (ou Chave Primária):

- SE o registro EXISTE na tabela de destino (_match_ na chave): Atualiza (Update) as colunas do registro existente com os novos valores da fonte de origem.

- SE o registro NÃO EXISTE na tabela de destino (não há _match_ na chave): Insere (_Insert_) o novo registro na tabela de destino.

<br>

---

## Cenários de Uso Comuns

O _Upsert_ é amplamente utilizado em Engenharia de Dados, ETL/ELT e _Data Warehousing_:

- Sincronização de Dados: É a base para manter tabelas de dimensão em _Data Warehouses_ atualizadas, garantindo que novos clientes sejam inseridos e que os dados de clientes existentes (como endereço ou nome) sejam corrigidos.
- Processamento de _Streams_: Em sistemas de processamento em tempo real (como _Apache Kafka_ ou _Flink_), o _Upsert_ é usado para garantir que o estado de uma entidade seja consistentemente atualizado, tratando eventos novos ou modificações.
- Pandas/PySpark: Em ambientes como _PySpark_ (com Delta Lake) ou Pandas, a lógica _Upsert_ é implementada para fundir (merge) DataFrames de forma eficiente.
vision-agents-plugins-smart-turn 0.3.6
Smart Turn detection plugin for Vision Agents
Requires Python: >=3.10

# Smart Turn Detection Plugin

An AI-powered turn detection plugin for Vision Agents that uses the [Smart Turn model](https://github.com/pipecat-ai/smart-turn) to detect when a speaker has completed their turn in a conversation.

## Overview

Smart Turn is an open-source, community-driven, native audio turn detection model that goes beyond simple Voice Activity Detection (VAD). It analyzes grammar, tone, pace of speech, and various other complex audio and semantic cues to determine when a user has finished speaking, matching human expectations more closely than VAD-based approaches.

For more information about the Smart Turn model, visit the [official repository](https://github.com/pipecat-ai/smart-turn).

## Installation

```bash
pip install vision-agents-plugins-smart-turn
```

## Usage

```python
from vision_agents.plugins.smart_turn import TurnDetection

# Initialize with FAL API key from environment variable
turn_detector = TurnDetection()

# Or specify API key directly
turn_detector = TurnDetection(api_key="your_fal_api_key")


# Register event handlers
@turn_detector.on("turn_started")
def on_turn_started(event_data):
    print(f"Turn started: {event_data.participant}")


@turn_detector.on("turn_ended")
def on_turn_ended(event_data):
    print(f"Turn ended: {event_data.participant} (confidence: {event_data.confidence:.3f})")


# Start detection
turn_detector.start()

# Process audio
await turn_detector.process_audio(pcm_data, user_id="user123")

# Stop detection
turn_detector.stop()
```

## Configuration Options

- `api_key`: FAL API key (default: reads from FAL_KEY environment variable)
- `buffer_duration`: Duration in seconds to buffer audio before processing (default: 2.0)
- `confidence_threshold`: Probability threshold for "complete" predictions (default: 0.5)
- `sample_rate`: Audio sample rate in Hz (default: 16000)
- `channels`: Number of audio channels (default: 1)
vision-agents-plugins-deepgram 0.3.6
Deepgram STT and TTS integration for Vision Agents
Requires Python: >=3.10
Keywords: AI, STT, TTS, agents, deepgram, speech-to-text, text-to-speech, transcription, voice agents

# Deepgram Plugin

Speech-to-Text (STT) and Text-to-Speech (TTS) plugins for Vision Agents using the Deepgram API.

## Installation

```bash
uv add vision-agents-plugins-deepgram
```

## Speech-to-Text (STT)

High-quality speech recognition using Deepgram's Flux model with built-in turn detection.

```python
from vision_agents.plugins import deepgram

stt = deepgram.STT(
    model="flux-general-en",  # Default model
    eager_turn_detection=True,  # Enable eager end-of-turn detection
)
```

### STT Docs

- https://developers.deepgram.com/docs/flux/quickstart
- https://github.com/deepgram/deepgram-python-sdk/blob/main/examples/listen/v2/connect/async.py

## Text-to-Speech (TTS)

Low-latency text-to-speech using Deepgram's Aura model via WebSocket streaming.

```python
from vision_agents.plugins import deepgram

tts = deepgram.TTS(
    model="aura-2-thalia-en",  # Default voice
    sample_rate=16000,  # Audio sample rate
)
```

### Available Voices

Deepgram offers various Aura voice models:
- `aura-2-thalia-en` - Default female voice
- `aura-2-orion-en` - Male voice
- See [TTS Models](https://developers.deepgram.com/docs/tts-models) for all options

### TTS Docs

- https://developers.deepgram.com/docs/tts-websocket
- https://developers.deepgram.com/docs/streaming-text-to-speech

## Environment Variables

Set `DEEPGRAM_API_KEY` in your environment or pass `api_key` to the constructor.

## Example

See the [example](./example/) directory for a complete working example using both STT and TTS.
vision-agents-plugins-inworld 0.3.6
Inworld AI TTS integration for Vision Agents
Requires Python: >=3.10
Keywords: AI, TTS, agents, inworld, text-to-speech, voice agents

# Inworld AI Text-to-Speech Plugin

A high-quality Text-to-Speech (TTS) plugin for Vision Agents that uses the Inworld AI API with streaming support.

## Installation

```bash
uv add vision-agents[inworld]
```

## Usage

```python
from vision_agents.plugins import inworld

# Initialize with API key from environment variable
tts = inworld.TTS()

# Or specify API key and other options directly
tts = inworld.TTS(
    api_key="your_inworld_api_key",
    voice_id="Dennis",
    model_id="inworld-tts-1.5-max",
    temperature=1.1
)

# Use with an Agent
from vision_agents.core import Agent
from vision_agents.plugins import getstream, gemini, smart_turn

agent = Agent(
    edge=getstream.Edge(),
    tts=inworld.TTS(),
    llm=gemini.LLM(),
    turn_detection=smart_turn.TurnDetection(),
)
```

## Configuration Options

- `api_key`: Inworld AI API key (default: reads from `INWORLD_API_KEY` environment variable)
- `voice_id`: The voice ID to use for synthesis (default: "Dennis")
- `model_id`: The model ID to use for synthesis. Options: "inworld-tts-1.5-max", "inworld-tts-1.5-min" "inworld-tts-1", "inworld-tts-1-max" (default: "inworld-tts-1.5-max")
- `temperature`: Determines the degree of randomness when sampling audio tokens. Accepts values between 0 and 2 (default: 1.1)

## Requirements

- Python 3.10+
- httpx>=0.27.0
  "av>=10.0.0",

## Getting Started

1. Get your Inworld AI API key from the [Inworld Portal](https://studio.inworld.ai/)
2. Set the `INWORLD_API_KEY` environment variable:
   ```bash
   export INWORLD_API_KEY="your_api_key_here"
   ```
3. Use the plugin in your Vision Agents application

## API Reference

The plugin implements the standard Vision Agents TTS interface:

- `stream_audio(text: str)`: Convert text to speech and return an async iterator of `PcmData` chunks
- `stop_audio()`: Stop audio playback (no-op for this plugin)
- `send(text: str)`: Send text to be converted to speech (inherited from base class)
vision-agents-plugins-kokoro 0.3.6
Kokoro TTS integration for Vision Agents
Requires Python: >=3.10
Keywords: AI, TTS, agents, kokoro, text-to-speech, voice agents

# GetStream Kokoro Plugin

This package integrates the open-weight [Kokoro-82M TTS model](https://github.com/hexgrad/kokoro) with the GetStream audio/video SDK.

It provides a drop-in `KokoroTTS` class that implements the common `getstream_common.tts.TTS` interface, allowing you to stream PCM audio generated by Kokoro directly into a WebRTC `AudioStreamTrack`.

```py
from getstream.plugins.kokoro import KokoroTTS
from getstream.video.rtc.audio_track import AudioStreamTrack

track = AudioStreamTrack(framerate=24_000)

tts = KokoroTTS(lang_code="a", voice="af_heart")
tts.set_output_track(track)

await tts.send("Hello from Kokoro!")
```

## Installation

```bash
pip install getstream-plugins-kokoro
```

This will pull in the required `kokoro`, `numpy` and `getstream[webrtc"]` dependencies.  You also need `espeak-ng` **at runtime** for pronunciation fallback.  On macOS you can install it with Homebrew:

```bash
brew install espeak-ng
```

## Configuration options

| Parameter | Default | Description |
|-----------|---------|-------------|
| `lang_code` | `"a"` | Language group passed to `KPipeline` (`"a"` = American English, etc.) |
| `voice` | `"af_heart"` | Kokoro voice preset.  See the [model card](https://huggingface.co/NeuML/kokoro-int8-onnx#speaker-reference) for available options. |
| `speed` | `1.0` | Playback speed multiplier. |
| `sample_rate` | `24000` | Output sample-rate (fixed by Kokoro).  **The attached `AudioStreamTrack` must use the same value.** |
vision-agents-plugins-getstream 0.3.6
GetStream video/voice integration for Vision Agents
Requires Python: >=3.10
Keywords: AI, agents, getstream, realtime, streaming, video, voice agents

# GetStream Plugin

A plugin for Stream Agents that provides GetStream integration.

## Installation

```bash
pip install vision-agents-plugins-getstream
```

## Usage

```python
from vision_agents.plugins import getstream

# Use the plugin
```

## Development

This plugin follows the standard Stream Agents plugin structure.
vision-agents-plugins-openrouter 0.3.6
OpenRouter plugin for vision agents
Requires Python: >=3.10

# OpenRouter Plugin

This plugin provides LLM capabilities using OpenRouter's API, which offers access to multiple LLM providers through a unified OpenAI-compatible interface. It enables developers to easily switch between different models from various providers (Anthropic, Google, OpenAI, etc.) without changing their code.

## Features

- Access to multiple LLM providers through a single API
- OpenAI-compatible interface for easy integration
- Support for various models including Claude, Gemini, GPT, and more
- Automatic conversion of instructions to system messages
- Manual conversation history management

## Installation

```bash
uv add vision-agents[openrouter]
```

## Usage

```python
from vision_agents.core import User, Agent
from vision_agents.plugins import openrouter, getstream, elevenlabs, deepgram, smart_turn

agent = Agent(
    edge=getstream.Edge(),
    agent_user=User(name="OpenRouter AI"),
    instructions="Be helpful and friendly to the user",
    llm=openrouter.LLM(
        model="anthropic/claude-haiku-4.5",
    ),
    tts=elevenlabs.TTS(),
    stt=deepgram.STT(),
    turn_detection=smart_turn.TurnDetection(),
)
```

## Configuration

| Parameter | Description | Accepted Values |
|-----------|-------------|----------------|
| `api_key` | OpenRouter API key | `str \| None`. If not provided, uses `OPENROUTER_API_KEY` environment variable |
| `base_url` | OpenRouter API base URL | `str`. Default: `"https://openrouter.ai/api/v1"` |
| `model` | Model identifier to use | `str`. Default: `"openrouter/andromeda-alpha"`. Examples: `"anthropic/claude-haiku-4.5"`, `"google/gemini-2.5-flash"`, `"openai/gpt-4o"` |
| `**kwargs` | Additional arguments passed to OpenAI LLM | Any additional parameters supported by the underlying OpenAI LLM implementation |

## Dependencies

- vision-agents
- vision-agents-plugins-openai
vision-agents-plugins-mistral 0.3.6
Mistral Voxtral STT integration for Vision Agents
Requires Python: >=3.10
Keywords: AI, STT, agents, mistral, real-time, speech-to-text, transcription, voice agents, voxtral

# Mistral Voxtral STT Plugin

Mistral Voxtral realtime speech-to-text integration for Vision Agents.

## Features

- Real-time speech recognition via WebSocket streaming
- Low-latency transcription using Voxtral models
- Automatic language detection
- Partial transcript streaming for responsive UX
- Sentence-level final transcripts (triggered by `.`, `?`, `!`)

## Installation

```bash
uv add vision-agents[mistral]
```

## Usage

```python
from vision_agents.core import Agent, Runner, User
from vision_agents.core.agents import AgentLauncher
from vision_agents.plugins import deepgram, gemini, getstream, mistral


async def create_agent(**kwargs) -> Agent:
    return Agent(
        edge=getstream.Edge(),
        agent_user=User(name="Assistant", id="agent"),
        instructions="You're a helpful voice AI assistant. Keep replies short and conversational.",
        stt=mistral.STT(),
        tts=deepgram.TTS(),
        llm=gemini.LLM(),
    )


async def join_call(agent: Agent, call_type: str, call_id: str, **kwargs) -> None:
    await agent.create_user()
    call = await agent.create_call(call_type, call_id)

    async with agent.join(call):
        await agent.run()


if __name__ == "__main__":
    Runner(AgentLauncher(create_agent=create_agent, join_call=join_call)).cli()
```

Run with:

```bash
uv run plugins/mistral/example/mistral_stt_example.py run
```

## Turn Detection

Mistral Voxtral STT does not include built-in turn detection (`turn_detection=False`). You'll need to pair it with an external turn detection plugin.

## Configuration

| Parameter     | Description                                              | Default                                 |
|---------------|----------------------------------------------------------|-----------------------------------------|
| `api_key`     | Mistral API key                                          | `MISTRAL_API_KEY` env var               |
| `model`       | Model identifier                                         | `voxtral-mini-transcribe-realtime-2602` |
| `sample_rate` | Audio sample rate (Hz): 8000, 16000, 22050, 44100, 48000 | `16000`                                 |
| `client`      | Pre-configured Mistral client                            | `None`                                  |

## Events

The plugin emits standard STT events:

- `STTTranscriptEvent`: Final transcript (emitted at sentence boundaries or stream end)
- `STTPartialTranscriptEvent`: Partial word/delta as transcription streams

## Dependencies

- `mistralai[realtime]>=1.12.0`
- `vision-agents`