LFM3 di Liquid AI: i nuovi modelli 2B per testo, visione, audio e omni

Avvia il server con i sampling parameter della model card. --no-reasoning-preserve evita di conservare nella history il reasoning dei turni precedenti:

llama serve -hf LiquidAI/LFM3-VL-2B-GGUF:Q8_0 \
  --temp 0.1 --top-p 1.0 --top-k 50 --min-p 0.0 --repeat-penalty 1.1 \
  --no-reasoning-preserve --port 8080

Invia l'immagine come data URI in base64 e chiedi un JSON. Il server separa il reasoning dalla risposta, quindi message.content contiene solo l'output finale:

import base64
import json
from openai import OpenAI

client = OpenAI(base_url="http://localhost:8080/v1", api_key="none")

with open("scontrino.jpg", "rb") as f:
    image_b64 = base64.b64encode(f.read()).decode()

prompt = (
    "Estrai dallo scontrino un oggetto JSON con le chiavi "
    "esercente, data (AAAA-MM-GG), totale (numero) e righe "
    "(lista di oggetti con descrizione e importo). "
    "Rispondi solo con il JSON."
)

response = client.chat.completions.create(
    model="lfm3-vl-2b",
    messages=[{
        "role": "user",
        "content": [
            {"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{image_b64}"}},
            {"type": "text", "text": prompt},
        ],
    }],
    temperature=0.1,
)

text = response.choices[0].message.content.strip()
text = text.removeprefix("```json").removesuffix("```").strip()
receipt = json.loads(text)
print(receipt["totale"], len(receipt["righe"]))

Controlla sempre i campi estratti, per esempio verificando che la somma delle righe corrisponda al totale. Per formati ricorrenti Liquid AI offre un notebook SFT pensato proprio per estrarre JSON dalle foto degli scontrini.

Con llama cli -st (single turn) poni una sola domanda su un video e il programma termina dopo la risposta. Serve ffmpeg nel PATH:

llama cli -st -hf LiquidAI/LFM3-VL-2B-GGUF:Q8_0 \
  --temp 0.1 --top-p 1.0 --top-k 50 --min-p 0.0 --repeat-penalty 1.1 \
  --video sopralluogo.mp4 \
  -p "Elenca i difetti visibili sulla facciata, nell'ordine in cui compaiono, e indica quale sembra più urgente."

In llama.cpp questo modello campiona sempre a 2 fps, da 4 a 768 frame, e --video-fps viene ignorato. Oltre i 6 minuti e mezzo circa scatta il limite dei 768 frame. Ogni frame occupa token di contesto, quindi con clip brevi e mirate ottieni risultati più affidabili.

Per scegliere tu quale projector caricare, scarica i file e passali a mano:

hf download LiquidAI/LFM3-VL-2B-GGUF \
  LFM3-VL-2B-Q8_0.gguf mmproj-LFM3-VL-2B-Q8_0.gguf --local-dir models

llama serve -m models/LFM3-VL-2B-Q8_0.gguf \
  --mmproj models/mmproj-LFM3-VL-2B-Q8_0.gguf \
  --temp 0.1 --top-p 1.0 --top-k 50 --min-p 0.0 --repeat-penalty 1.1 \
  --no-reasoning-preserve --port 8080

Il projector Q8_0 pesa 0,20 GB, quello F16 0,38 GB.

Invia nello stesso messaggio l'immagine e la registrazione della domanda. I system prompt in inglese sono quelli indicati nella model card, mentre la domanda può essere in italiano:

import base64
from openai import OpenAI

client = OpenAI(base_url="http://localhost:8080/v1", api_key="none")

def b64(path):
    with open(path, "rb") as f:
        return base64.b64encode(f.read()).decode()

response = client.chat.completions.create(
    model="lfm3-omni-2b",
    messages=[
        {
            "role": "system",
            "content": "Answer questions about the provided image. "
                       "Base every answer only on what can be seen. Respond with text.",
        },
        {
            "role": "user",
            "content": [
                {"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{b64('quadro.jpg')}"}},
                {"type": "input_audio", "input_audio": {"data": b64("domanda.wav"), "format": "wav"}},
            ],
        },
    ],
    temperature=0,
)
print(response.choices[0].message.content)

llama.cpp riconosce il formato audio dal contenuto del file (wav, mp3, flac).

Con il system prompt della model card il modello vede i frame e ascolta l'audio del video. Serve ffmpeg nel PATH:

llama cli -st -hf LiquidAI/LFM3-Omni-2B-GGUF:Q8_0 \
  --video motore.mp4 \
  -sys "Answer questions about the video using what you see and hear." \
  -p "Da quale parte del motore sembra provenire il rumore metallico?" --temp 0

In llama.cpp il video viene campionato a 2 fps, da 4 a 384 frame. La traccia audio invece viene sempre elaborata per intero.

Lo stesso server espone il WebSocket /v1/realtime, compatibile con la Realtime API di OpenAI. L'audio viene elaborato mentre arriva, quindi la risposta parte subito dopo l'ultimo chunk. Il repository di llama.cpp include un client di esempio:

git clone --depth 1 --branch v0.8.0 https://github.com/ggml-org/llama.cpp
pip install "openai[realtime]" numpy

python llama.cpp/examples/realtime_client.py \
  --url http://127.0.0.1:8080/v1 \
  --output-modalities text,audio --out risposta.wav domanda.wav

Il client legge file wav PCM16 e salva la risposta vocale in risposta.wav. Con --output-modalities text,audio usa il system prompt della model card per ottenere testo e voce interleaved.

Converti la registrazione in wav mono a 16 kHz, il sample rate dell'encoder. Per sicurezza dividila in segmenti brevi, perché il contesto del modello è di 32K token:

ffmpeg -i riunione.m4a -ac 1 -ar 16000 -c:a pcm_s16le riunione.wav
ffmpeg -i riunione.wav -f segment -segment_time 120 -c copy parte_%03d.wav

Trascrivi ogni segmento con il system prompt della model card:

for f in parte_*.wav; do
  llama cli -st -hf LiquidAI/LFM3-Audio-2B-GGUF:Q8_0 \
    --audio "$f" -sys "Perform ASR in Italian." -p "<__media__>" --temp 0 \
    >> verbale.txt
done

-st esegue un solo turno e poi chiude il programma, così il ciclo passa al file successivo. <__media__> indica dove inserire l'audio nel prompt. Con Perform ASR. il modello riconosce da solo la lingua.

Avvia il server. L'endpoint POST /tts restituisce un file wav e accetta lingua e voce (female o male):

llama serve -hf LiquidAI/LFM3-Audio-2B-GGUF:Q8_0 --port 8080

curl -X POST http://127.0.0.1:8080/tts \
  -H "Content-Type: application/json" \
  -d '{"input": "La riunione delle 15 è spostata in sala due.", "lang": "it", "voice": "female"}' \
  -o avviso.wav

I sampling parameter audio della model card sono già salvati nel GGUF. Il modello non supporta il voice cloning.

Con il server avviato, il client realtime di llama.cpp mette a disposizione un tool di esempio, set_volume. Il modello trasforma il comando vocale in una tool call, il client la esegue e restituisce il risultato al modello:

python llama.cpp/examples/realtime_client.py \
  --url http://127.0.0.1:8080/v1 --tools comando.wav

In un'applicazione reale sostituisci il tool di esempio con le tue funzioni, per esempio luci, proiettore o calendario. Il system prompt consigliato è Respond with function calls, and interleaved text and audio. seguito dall'elenco dei tool.