Asterisk + Whisper open source : transcription 100% locale

# Installer les drivers NVIDIA + CUDA
apt install -y nvidia-driver firmware-misc-nonfree
# Verifier CUDA
nvidia-smi

# Installer faster-whisper avec support CUDA
pip install faster-whisper

# faster-whisper fonctionne aussi en CPU (plus lent mais viable)
pip install faster-whisper

# Verifier le support AVX2 (important pour les performances)
grep -o 'avx2' /proc/cpuinfo | head -1

# Le modele se telecharge automatiquement au premier lancement
# Vous pouvez aussi le pre-telecharger :
python3 -c "
from faster_whisper import WhisperModel
model = WhisperModel('large-v3', device='cuda', compute_type='int8_float16')
print('Modele telecharge avec succes')
"

#!/usr/bin/env python3
# /usr/local/bin/whisper-local-transcribe.py
# Transcription locale avec faster-whisper — aucune donnee externe.
import sys
import os
import json
import logging
from datetime import datetime
from pathlib import Path

from faster_whisper import WhisperModel

# ── Configuration ──
MODEL_SIZE = os.environ.get('WHISPER_MODEL', 'large-v3')
DEVICE = os.environ.get('WHISPER_DEVICE', 'cuda')       # 'cuda' ou 'cpu'
COMPUTE_TYPE = os.environ.get('WHISPER_COMPUTE', 'int8_float16')  # GPU: int8_float16, CPU: int8
LANGUAGE = os.environ.get('WHISPER_LANG', 'fr')
DB_PATH = os.environ.get('TRANSCRIPTION_DB', '/var/lib/asterisk/transcriptions.jsonl')
WEBHOOK_URL = os.environ.get('WEBHOOK_URL', '')

# ── Logging ──
logging.basicConfig(
    filename='/var/log/whisper-transcribe.log',
    level=logging.INFO,
    format='%(asctime)s %(levelname)s %(message)s'
)
log = logging.getLogger(__name__)

# ── Charger le modele une seule fois (si lance comme service) ──
_model = None

def get_model():
    global _model
    if _model is None:
        log.info(f'Loading model {MODEL_SIZE} on {DEVICE} ({COMPUTE_TYPE})')
        _model = WhisperModel(
            MODEL_SIZE,
            device=DEVICE,
            compute_type=COMPUTE_TYPE,
        )
        log.info('Model loaded')
    return _model


def transcribe(file_path: str) -> dict:
    model = get_model()

    segments, info = model.transcribe(
        file_path,
        language=LANGUAGE,
        beam_size=5,
        vad_filter=True,          # Silero VAD : ignore les silences
        vad_parameters=dict(
            min_silence_duration_ms=500,
            speech_pad_ms=200,
        ),
        word_timestamps=True,
    )

    result_segments = []
    full_text = []
    for seg in segments:
        result_segments.append({
            'start': round(seg.start, 2),
            'end': round(seg.end, 2),
            'text': seg.text.strip(),
        })
        full_text.append(seg.text.strip())

    return {
        'text': ' '.join(full_text),
        'language': info.language,
        'language_probability': round(info.language_probability, 3),
        'duration': round(info.duration, 2),
        'segments': result_segments,
    }


def save_transcription(unique_id: str, result: dict):
    entry = {
        'unique_id': unique_id,
        'timestamp': datetime.now().isoformat(),
        **result,
    }
    db_path = Path(DB_PATH)
    db_path.parent.mkdir(parents=True, exist_ok=True)
    with open(db_path, 'a') as f:
        f.write(json.dumps(entry, ensure_ascii=False) + '\n')
    log.info(f'Saved {unique_id}: {len(result["text"])} chars, {result["duration"]}s')


def send_webhook(unique_id: str, result: dict):
    if not WEBHOOK_URL:
        return
    import requests
    try:
        requests.post(WEBHOOK_URL, json={
            'unique_id': unique_id,
            'text': result['text'],
            'duration': result['duration'],
        }, timeout=10)
    except Exception as e:
        log.error(f'Webhook error: {e}')


def main():
    if len(sys.argv) < 3:
        print(f'Usage: {sys.argv[0]} <audio_file> <unique_id>')
        sys.exit(1)

    audio_file = sys.argv[1]
    unique_id = sys.argv[2]

    if not os.path.isfile(audio_file):
        log.error(f'Not found: {audio_file}')
        sys.exit(1)

    file_size = os.path.getsize(audio_file)
    if file_size < 1024:
        log.warning(f'Too small ({file_size}B), skipping')
        sys.exit(0)

    log.info(f'Transcribing {audio_file} ({file_size}B) for {unique_id}')

    try:
        result = transcribe(audio_file)
        save_transcription(unique_id, result)
        send_webhook(unique_id, result)
        log.info(f'Done: {unique_id}')
    except Exception as e:
        log.error(f'Failed {unique_id}: {e}')
        sys.exit(1)


if __name__ == '__main__':
    main()

chmod +x /usr/local/bin/whisper-local-transcribe.py

; extensions.conf
[from-internal]
exten => _0XXXXXXXXX,1,NoOp(Appel sortant vers ${EXTEN})
 same => n,Set(RECORDING_FILE=/var/spool/asterisk/recordings/${UNIQUEID})
 same => n,MixMonitor(${RECORDING_FILE}.wav,b)
 same => n,Dial(PJSIP/${EXTEN}@trunk-operateur,60,tT)
 same => n,Hangup()

exten => h,1,NoOp(Post-hangup : transcription locale)
 same => n,System(/usr/local/bin/whisper-local-transcribe.sh ${RECORDING_FILE}.wav ${UNIQUEID} &)

#!/bin/bash
# /usr/local/bin/whisper-local-transcribe.sh
RECORDING="$1"
UNIQUEID="$2"

[ ! -s "$RECORDING" ] && exit 1

# Convertir en 16kHz mono pour de meilleures performances
OPTIMIZED="${RECORDING%.wav}_16k.wav"
sox "$RECORDING" -r 16000 -c 1 "$OPTIMIZED" 2>/dev/null || cp "$RECORDING" "$OPTIMIZED"

# Variables d'environnement
export WHISPER_MODEL="${WHISPER_MODEL:-large-v3}"
export WHISPER_DEVICE="${WHISPER_DEVICE:-cuda}"
export WHISPER_COMPUTE="${WHISPER_COMPUTE:-int8_float16}"

/usr/local/bin/whisper-local-transcribe.py "$OPTIMIZED" "$UNIQUEID"
rm -f "$OPTIMIZED"

chmod +x /usr/local/bin/whisper-local-transcribe.sh

pip install fastapi uvicorn python-multipart

#!/usr/bin/env python3
# /opt/whisper-service/server.py
# Service de transcription locale persistent.
import os
import tempfile
import logging

from fastapi import FastAPI, UploadFile, File
from faster_whisper import WhisperModel

logging.basicConfig(level=logging.INFO)
log = logging.getLogger(__name__)

MODEL_SIZE = os.environ.get('WHISPER_MODEL', 'large-v3')
DEVICE = os.environ.get('WHISPER_DEVICE', 'cuda')
COMPUTE_TYPE = os.environ.get('WHISPER_COMPUTE', 'int8_float16')

app = FastAPI(title='Whisper Local Service')

log.info(f'Loading {MODEL_SIZE} on {DEVICE}...')
model = WhisperModel(MODEL_SIZE, device=DEVICE, compute_type=COMPUTE_TYPE)
log.info('Model loaded, ready to serve')


@app.post('/transcribe')
async def transcribe_endpoint(
    file: UploadFile = File(...),
    language: str = 'fr',
):
    # Sauvegarder le fichier temporaire
    with tempfile.NamedTemporaryFile(suffix='.wav', delete=False) as tmp:
        content = await file.read()
        tmp.write(content)
        tmp_path = tmp.name

    try:
        segments, info = model.transcribe(
            tmp_path,
            language=language,
            beam_size=5,
            vad_filter=True,
        )

        result_segments = []
        full_text = []
        for seg in segments:
            result_segments.append({
                'start': round(seg.start, 2),
                'end': round(seg.end, 2),
                'text': seg.text.strip(),
            })
            full_text.append(seg.text.strip())

        return {
            'text': ' '.join(full_text),
            'language': info.language,
            'duration': round(info.duration, 2),
            'segments': result_segments,
        }
    finally:
        os.unlink(tmp_path)

# /etc/systemd/system/whisper-service.service
[Unit]
Description=Whisper Local Transcription Service
After=network.target

[Service]
Type=simple
User=asterisk
Environment=WHISPER_MODEL=large-v3
Environment=WHISPER_DEVICE=cuda
Environment=WHISPER_COMPUTE=int8_float16
ExecStart=/usr/local/bin/uvicorn server:app --host 127.0.0.1 --port 8765 --workers 1
WorkingDirectory=/opt/whisper-service
Restart=always
RestartSec=10

[Install]
WantedBy=multi-user.target

systemctl daemon-reload
systemctl enable --now whisper-service

# Tester
curl -X POST http://127.0.0.1:8765/transcribe \
  -F "file=@/tmp/test-recording.wav" \
  -F "language=fr"

#!/bin/bash
# /usr/local/bin/whisper-local-transcribe.sh (version service)
RECORDING="$1"
UNIQUEID="$2"

[ ! -s "$RECORDING" ] && exit 1

# Appel au service local (modele deja en memoire = rapide)
RESULT=$(curl -s -X POST http://127.0.0.1:8765/transcribe \
  -F "file=@${RECORDING}" -F "language=fr")

# Sauvegarder en JSON Lines
echo "{\"unique_id\":\"${UNIQUEID}\",\"timestamp\":\"$(date -Iseconds)\",\"result\":${RESULT}}" \
  >> /var/lib/asterisk/transcriptions.jsonl

# docker-compose.yml
services:
  whisper:
    build:
      context: .
      dockerfile: Dockerfile.whisper
    container_name: whisper-service
    restart: unless-stopped
    ports:
      - "127.0.0.1:8765:8765"
    environment:
      - WHISPER_MODEL=large-v3
      - WHISPER_DEVICE=cuda
      - WHISPER_COMPUTE=int8_float16
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 1
              capabilities: [gpu]
    volumes:
      - whisper_cache:/root/.cache/huggingface

volumes:
  whisper_cache:

# Dockerfile.whisper
FROM nvidia/cuda:12.2.2-runtime-ubuntu22.04

RUN apt-get update && apt-get install -y python3 python3-pip && rm -rf /var/lib/apt/lists/*
RUN pip3 install faster-whisper fastapi uvicorn python-multipart

WORKDIR /app
COPY server.py .

EXPOSE 8765
CMD ["uvicorn", "server:app", "--host", "0.0.0.0", "--port", "8765", "--workers", "1"]

# Installer Ollama
curl -fsSL https://ollama.com/install.sh | sh

# Telecharger un modele (Mistral 7B est un bon compromis)
ollama pull mistral

#!/usr/bin/env python3
# analyse_transcription.py
import json
import requests

OLLAMA_URL = 'http://localhost:11434/api/generate'

def analyze(transcription_text: str) -> dict:
    prompt = (
        "Analyse cette transcription d'appel telephonique.\n"
        "Retourne un JSON avec : sentiment, score, resume, mots_cles.\n\n"
        f"Transcription :\n{transcription_text}\n\nJSON:"
    )

    resp = requests.post(OLLAMA_URL, json={
        'model': 'mistral',
        'prompt': prompt,
        'stream': False,
        'format': 'json',
    }, timeout=60)

    return json.loads(resp.json()['response'])

# Verifier que le service tourne
systemctl status whisper-service

# Metriques GPU
nvidia-smi --query-gpu=utilization.gpu,memory.used,memory.total --format=csv -l 5

# Logs
journalctl -u whisper-service -f

# Test de charge
for i in $(seq 1 10); do
  curl -s -X POST http://127.0.0.1:8765/transcribe \
    -F "file=@test.wav" -F "language=fr" &
done
wait