Come chiamare Jev su AiHubMix: un tutorial di classificazione strutturata

Risposta breve: jev-1.13 non genera testo. Inviate un pezzo di testo insieme a un insieme di domande denominate a https://aihubmix.com/v1/systemone, e riceverete risposte digitate associate ai nomi delle vostre domande — una categoria, un punteggio o una probabilità. Niente da analizzare. Di seguito è riportata una richiesta funzionante, il formato completo della risposta e l'unico errore di design che vi costerà silenziosamente precisione.

A cosa serve Jev

Usatelo quando avete bisogno di un giudizio, non di un paragrafo: instradare un ticket di supporto, valutare la gravità, segnalare urgenza, controllare contenuti. La pagina del modello lo afferma chiaramente: "Nessuna generazione di testo, niente da analizzare."

Utilizzate invece un modello di chat normale quando avete bisogno di spiegazioni, riassunti o qualsiasi output libero. Jev non può produrre questi.

Prima di iniziare

• [ ] Python 3 installato (la libreria standard è sufficiente)
• [ ] Un account AiHubMix e una chiave API
• [ ] Chiave esportata come AIHUBMIX_API_KEY, mai hardcoded nel sorgente

Non avete non bisogno di un SDK OpenAI, LangChain o del pacchetto requests.

Passo 1 — Conoscere l'endpoint

POST https://aihubmix.com/v1/systemone
Authorization: Bearer YOUR_KEY
Content-Type: application/json

Questa è una rotta specifica per il modello, non /v1/chat/completions. I client compatibili con OpenAI non possono chiamarla. Utilizzate HTTP semplice.

Passo 2 — Scegliere i tipi di domande

Ce ne sono tre, e potete mescolarli liberamente in una richiesta:

Passo 3 — Costruire la richiesta

state è il testo da giudicare. questions le chiavi sono nomi che inventate; la risposta utilizza gli stessi nomi.

payload = {
    "model": "jev-1.13",
    "state": "Ciao, ho provato a collegare il mio account Stripe per 3 giorni "
             "e continua a fallire. Sto perdendo vendite. Per favore aiutatemi il prima possibile.",
    "questions": {
        "department": {
            "type": "choice",
            "instructions": "Quale team dovrebbe gestire questo",
            "criteria": {
                "billing":   "Problemi di pagamento o abbonamento",
                "technical": "Bug o problemi di integrazione",
                "sales":     "Domande sui prezzi o sull'account",
            },
        },
        "frustration": {
            "type": "score",
            "instructions": "Quanto sembra frustrato il cliente",
            "criteria": [
                "Calmo, sta solo esponendo fatti",
                "Frustrato ma civile",
                "Molto arrabbiato, linguaggio forte",
            ],
        },
        "is_urgent": {
            "type": "noul",
            "instructions": "Il messaggio trasmette urgenza o sensibilità al tempo",
        },
    },
}

Passo 4 — Inviarlo con la libreria standard

import json, os, urllib.error, urllib.request

def ask(payload):
    req = urllib.request.Request(
        "https://aihubmix.com/v1/systemone",
        data=json.dumps(payload).encode(),
        headers={"Authorization": "Bearer " + os.environ["AIHUBMIX_API_KEY"],
                 "Content-Type": "application/json"},
        method="POST",
    )
    try:
        with urllib.request.urlopen(req, timeout=60) as r:
            return json.loads(r.read())
    except urllib.error.HTTPError as e:
        raise SystemExit(f"HTTP {e.code}: {e.read().decode(errors='replace')[:500]}")

Mantenete la costruzione della richiesta all'interno di una funzione. Se costruite e inviate a livello di modulo, l'importazione del file riattiva la chiamata e consuma token.

Passo 5 — Leggere le risposte

Ogni risposta memorizza il suo valore sotto una chiave che corrisponde al suo type, quindi un accessor copre tutti e tre:

data = ask(payload)
for name, ans in data["answers"].items():
    kind = ans["type"]
    print(name, kind, ans[kind], ans.get("confidence"))
print("usage:", data.get("usage"))

Output verificato:

department   choice  billing   0.51
frustration  score   1         1
is_urgent    noul    1         None
usage: {'input_tokens': 424, 'output_tokens': 73}

Passo 6 — Comprendere l'intero pacchetto

Il ciclo di stampa nasconde campi utili. Il JSON grezzo per una risposta score è:

{
  "type": "score",
  "score": 1,
  "legend": {"0": "Calmo, sta solo esponendo fatti", "1": "Frustrato ma civile", "2": "Molto arrabbiato, linguaggio forte"},
  "probabilities": {"0": 0, "1": 1, "2": 0},
  "confidence": 1
}

• legend mappa l'indice al vostro stesso wording — l'intero è auto-descrittivo, quindi non avete bisogno di una tabella di ricerca nel vostro codice.
• probabilities fornisce l'intera distribuzione, utile per rilevare un quasi pareggio.
• noul non ha campo confidence. La sua probabilità è il segnale.

Il livello superiore restituisce anche usage, id, provider (TypeSafe), e la versione backend risolta typesafe/jev-1.13-20260917.

L'errore che vi costa precisione

Nella richiesta sopra, department ha restituito billing con una confidenza di 0.51. Ripetere la richiesta identica ha restituito la stessa etichetta a 0.38 — la risposta era stabile, la certezza dichiarata non lo era.

La causa è nei criteri, non nel modello. billing è "Problemi di pagamento o abbonamento" e technical è "Bug o problemi di integrazione." Un'integrazione Stripe che continua a fallire corrisponde genuinamente a entrambe. Il modello stava segnalando un'ambiguità che era scritta nello schema.

Due regole prima della produzione:

1. Scrivere criteri choice che siano mutuamente esclusivi. Se un umano esitasse tra due etichette, lo farà anche il modello.
2. Impostare una soglia di confidenza e instradare i risultati a bassa confidenza a una coda umana invece di accettarli come decisioni. Un modello che ammette incertezze è più prezioso di uno che le nasconde.

Lista di controllo pre-lancio

• [ ] Chiave caricata dall'ambiente o da un file in modalità 600 che il vostro VCS ignora
• [ ] Criteri choice esaminati per sovrapposizioni
• [ ] Soglia di confidenza definita, con un percorso di fallback al di sotto di essa
• [ ] Risposte noul gestite separatamente — non portano confidence
• [ ] Domande non utilizzate rimosse (3 domande costano 424 token di input; 2 costano 355)
• [ ] Risposte non 2xx registrate con il corpo grezzo

FAQ

Posso usare l'SDK OpenAI? No. /v1/systemone non è una rotta compatibile con OpenAI.

Può Jev restituire una frase o un riassunto? No. Risponde solo alle domande digitate che definite.

Quante domande per richiesta? I test verificati hanno utilizzato due e tre. Ogni domanda aggiunge token di input e output, quindi includete solo ciò su cui agirete.

Esiste un alias di versione? La pagina del modello elenca un alias jev-latest insieme a jev-1.13. Fissate la versione esplicita se la riproducibilità è importante.

Qual è il costo? La pagina del modello pubblica $0.0462 / M token di input e $0 / M token di output. Questi sono dati del fornitore — confermate i prezzi attuali prima di pianificare il budget.

Qual è la finestra di contesto? La pagina del modello è incoerente: 64K nel suo header, 32K nella tabella del fornitore. Verificate contro il vostro input più lungo prima di fare affidamento su entrambi.

Ambito di questa guida

Tutto quanto sopra è stato verificato con tre chiamate live contro un singolo input. Non copre latenza, batching, throughput o comportamento su input diversi dall'esempio. La deriva di confidenza è un'osservazione riprodotta, non un tasso di errore misurato — ripetetela sui vostri dati prima di impostare una soglia.

Iniziare su AiHubMix

jev-1.13 è disponibile tramite AiHubMix, e la pagina del modello contiene tutto ciò a cui si riferisce questo tutorial: l'endpoint /v1/systemone, i tre tipi di domande con i loro formati di criteria, i campi di risposta completi e i prezzi pubblicati di $0.0462 / M token di input con $0 / M token di output. L'alias jev-latest si risolve nella versione più recente, quindi rimane aggiornato man mano che le versioni cambiano.

Iniziate qui: https://aihubmix.com/model/jev-latest

Prossimi passi:

1. Creare un account AiHubMix e generare una chiave API
2. Copiare la richiesta dal Passo 3 e la funzione ask() dal Passo 4
3. Sostituire state con un record reale dalla vostra coda
4. Confrontare il risultato con come classificate quel record oggi

Se questa guida è stata utile, iscrivetevi per futuri post su modelli di output strutturato e pipeline di classificazione.