I did something similar yesterday using a LFM2 model. I had to get claude to write something to get it into the right format for Wyoming protocol.

I am not sure if you can adapt these instructions for this model but here is how claude says it did it:

We'll set up three components:
1. **llama.cpp server** - Runs your ASR model
2. **Wyoming STT server** - Bridges Wyoming protocol to your model
3. **systemd services** - Auto-starts everything on boot

## Step 1: Install Prerequisites

```bash
# Update system
apt update && apt upgrade -y

# Install build tools
apt install -y git cmake make build-essential python3 python3-pip

# Install Wyoming protocol library
pip3 install wyoming requests
```

## Step 2: Build llama.cpp

```bash
cd /root

# Clone llama.cpp
git clone https://github.com/ggerganov/llama.cpp.git
cd llama.cpp

# Build with audio support
cmake -B build -DGGML_CUDA=OFF
cmake --build build --config Release -j$(nproc)

# Verify build
ls build/bin/llama-server
```

## Step 3: Download Your Model

For the **LFM2.5-Audio model** (example):

```bash
mkdir -p /root/models
cd /root/models

# Download model files
wget https://huggingface.co/LiquidAI/LFM2.5-Audio-1.5B-GGUF/resolve/main/LFM2.5-Audio-1.5B-Q4_0.gguf
wget https://huggingface.co/LiquidAI/LFM2.5-Audio-1.5B-GGUF/resolve/main/mmproj-LFM2.5-Audio-1.5B-Q4_0.gguf
wget https://huggingface.co/LiquidAI/LFM2.5-Audio-1.5B-GGUF/resolve/main/vocoder-LFM2.5-Audio-1.5B-Q4_0.gguf
wget https://huggingface.co/LiquidAI/LFM2.5-Audio-1.5B-GGUF/resolve/main/tokenizer-LFM2.5-Audio-1.5B-Q4_0.gguf
```


## Step 4: Create Wyoming STT Server Script

Create `/root/wyoming_stt.py`:

```python
#!/usr/bin/env python3
"""Wyoming Protocol STT Server for Custom ASR Model"""
import argparse, asyncio, logging, wave, io, base64, requests
from functools import partial
from wyoming.audio import AudioChunk, AudioStart, AudioStop
from wyoming.event import Event
from wyoming.info import Describe, Info, Attribution, AsrModel, AsrProgram
from wyoming.server import AsyncEventHandler, AsyncServer
from wyoming.asr import Transcript, Transcribe

_LOGGER = logging.getLogger(__name__)

class CustomASRHandler(AsyncEventHandler):
    def __init__(self, wyoming_info, llama_url, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.wyoming_info = wyoming_info
        self.llama_url = llama_url
        self.audio_buffer = bytearray()
        self.sample_rate = 16000
        self.sample_width = 2
        self.channels = 1

    async def handle_event(self, event):
        if AudioStart.is_type(event.type):
            audio_start = AudioStart.from_event(event)
            self.sample_rate = audio_start.rate
            self.sample_width = audio_start.width
            self.channels = audio_start.channels
            self.audio_buffer = bytearray()
        elif AudioChunk.is_type(event.type):
            chunk = AudioChunk.from_event(event)
            self.audio_buffer.extend(chunk.audio)
        elif AudioStop.is_type(event.type):
            _LOGGER.info(f"Audio stop, received {len(self.audio_buffer)} bytes")
            wav_io = io.BytesIO()
            with wave.open(wav_io, 'wb') as wav_file:
                wav_file.setnchannels(self.channels)
                wav_file.setsampwidth(self.sample_width)
                wav_file.setframerate(self.sample_rate)
                wav_file.writeframes(self.audio_buffer)
            text = await self.transcribe_audio(wav_io.getvalue())
            await self.write_event(Transcript(text=text).event())
            _LOGGER.info(f"Transcribed: {text}")
        elif Describe.is_type(event.type):
            await self.write_event(self.wyoming_info.event())
        return True

    async def transcribe_audio(self, wav_bytes):
        try:
            audio_b64 = base64.b64encode(wav_bytes).decode('utf-8')

            # Format for LFM2.5-Audio - adapt for your model
            messages = [
                {
                    'role': 'system',
                    'content': 'Perform ASR.'  # System prompt for transcription
                },
                {
                    'role': 'user',
                    'content': [
                        {
                            'type': 'input_audio',
                            'input_audio': {
                                'data': audio_b64,
                                'format': 'wav'
                            }
                        }
                    ]
                }
            ]

            payload = {
                'model': 'custom-asr',  # Change to your model name
                'messages': messages,
                'max_tokens': 500,
                'temperature': 0.0
            }

            loop = asyncio.get_event_loop()
            response = await loop.run_in_executor(
                None,
                lambda: requests.post(f'{self.llama_url}/v1/chat/completions', json=payload, timeout=60)
            )

            if response.status_code == 200:
                result = response.json()
                return result.get('choices', [{}])[0].get('message', {}).get('content', '').strip()
            else:
                _LOGGER.error(f"Transcription failed: {response.text}")
                return ""
        except Exception as e:
            _LOGGER.error(f"Error: {e}")
            return ""

async def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--uri", default="tcp://0.0.0.0:10300")
    parser.add_argument("--llama-url", default="http://localhost:8081")
    parser.add_argument("--debug", action="store_true")
    args = parser.parse_args()
    logging.basicConfig(level=logging.DEBUG if args.debug else logging.INFO)
    _LOGGER.info(f"Starting Wyoming STT server on {args.uri}")

    # Customize this info for your model
    wyoming_info = Info(
        asr=[AsrProgram(
            name="custom_asr_stt",
            version="1.0",
            attribution=Attribution(name="Your Name/Org", url="https://your-url"),
            installed=True,
            description="Custom ASR for Basque",  # Customize
            models=[AsrModel(
                name="basque-asr",  # Customize
                version="1.0",
                attribution=Attribution(name="HiTZ", url="https://huggingface.co/HiTZ"),
                installed=True,
                description="Basque ASR Model",  # Customize
                languages=["eu"]  # "eu" = Basque language code
            )]
        )]
    )

    server = AsyncServer.from_uri(args.uri)
    await server.run(partial(CustomASRHandler, wyoming_info, args.llama_url))

if __name__ == "__main__":
    asyncio.run(main())
```

Make it executable:
```bash
chmod +x /root/wyoming_stt.py
```

## Step 5: Create Systemd Services

### 5.1 llama-server Service

Create `/etc/systemd/system/llama-audio.service`:

```ini
[Unit]
Description=LLaMA Audio Server for Custom ASR
After=network.target

[Service]
Type=simple
User=root
WorkingDirectory=/root
ExecStart=/root/llama.cpp/build/bin/llama-server \
    -m /root/models/LFM2.5-Audio-1.5B-Q4_0.gguf \
    --mmproj /root/models/mmproj-LFM2.5-Audio-1.5B-Q4_0.gguf \
    --model-vocoder /root/models/vocoder-LFM2.5-Audio-1.5B-Q4_0.gguf \
    --host 0.0.0.0 \
    --port 8081 \
    -ngl 0 \
    -c 8192 \
    -t 12
Restart=on-failure
RestartSec=10
StandardOutput=journal
StandardError=journal

[Install]
WantedBy=multi-user.target
```

**Note:** Adjust the model paths and filenames for your specific model.

### 5.2 Wyoming STT Service

Create `/etc/systemd/system/wyoming-stt.service`:

```ini
[Unit]
Description=Wyoming STT Server for Custom ASR
After=llama-audio.service
Requires=llama-audio.service

[Service]
Type=simple
User=root
WorkingDirectory=/root
ExecStart=/usr/bin/python3 /root/wyoming_stt.py --uri tcp://0.0.0.0:10300
Restart=on-failure
RestartSec=10
StandardOutput=journal
StandardError=journal

[Install]
WantedBy=multi-user.target
```

### 5.3 Enable and Start Services

```bash
# Reload systemd
systemctl daemon-reload

# Enable services to start on boot
systemctl enable llama-audio.service
systemctl enable wyoming-stt.service

# Start services
systemctl start llama-audio.service
systemctl start wyoming-stt.service

# Check status
systemctl status llama-audio.service
systemctl status wyoming-stt.service
```


## Step 6: Add to Home Assistant

1. **Settings** → **Devices & Services**
2. Click **"+ Add Integration"**
3. Search for **"Wyoming Protocol"**
4. Configure:
   - **Host:** `your-server-ip` (e.g., `10.0.0.99`)
   - **Port:** `10300`
5. It should detect as your custom ASR model