Des décisions typées sur CPU, en millisecondes.

Sabaki envoie un texte au bon petit classifieur et renvoie une réponse typée, un choix, un score ou un oui/non, avec une confiance calibrée. Pas de GPU, pas de clé d’API, pas de coût par appel.

npm i sabaki

Lire le guide npm GitHub

  • Licence MIT
  • Aucune dépendance d’exécution en mode nano
  • Sert un endpoint HTTP System One compatible Jev

Essayez. Tout tourne dans votre navigateur.

Mascotte shiba inu qui jette un œil par-dessus la console de décision

Routeur

  • customer_service 0,46
  • invoice_processing 1,24
  • security_incidents 0,00
  • agent_trace_observability 0,00

A choisi @sabaki-js/invoice-processing avec un score de 1,24 (seuil 0,15).

Réponses typées

QuestionRéponseConfiance
duplicateprincipale false 0,914automatiser
discrepancy_severity 2 0,575à vérifier
disposition hold 0,459à vérifier
matches_order false 0,673à vérifier
urgency 2 0,633à vérifier

La confiance de 0,914 dépasse 0,8 : on peut automatiser.

5 questions routées et traitées à la compilation, avec le même code.

Voir le JSON
{
  "model": "@sabaki-js/invoice-processing@1.0.0+nano",
  "answers": {
    "duplicate": {
      "type": "choice",
      "choice": "false",
      "confidence": 0.914
    },
    "discrepancy_severity": {
      "type": "choice",
      "choice": "2",
      "confidence": 0.575
    },
    "disposition": {
      "type": "choice",
      "choice": "hold",
      "confidence": 0.459
    },
    "matches_order": {
      "type": "choice",
      "choice": "false",
      "confidence": 0.673
    },
    "urgency": {
      "type": "choice",
      "choice": "2",
      "confidence": 0.633
    }
  }
}

Ce sont les vrais poids nano des greffons sabaki-js, exécutés par un portage du routeur et du prédicteur de la bibliothèque. Rien ne quitte cette page. Les greffons ont été entraînés sur les états structurés en anglais du benchmark : un texte libre obtient donc une confiance modeste, et c’est exactement à cela que sert ce chiffre.

Assez rapide pour une boucle de jeu

  • < 1 mspar décision avec nano, sur un CPU
  • 12–18krequêtes nano par seconde sur un seul thread
  • ~20 mspar décision avec mini, ONNX int8
  • 22 Mopour un modèle mini, contre 90 Mo
  • 0GPU, clé d’API ou frais par appel
Mascotte shiba inu qui dort paisiblement sur une puce CPU

Mesuré par les auteurs de Sabaki sur un Intel i5 et un Xeon, un seul thread. Le script de benchmark est dans le dépôt plugin-doom.

Une autre façon de livrer des décisions d’IA

On sollicite souvent un grand modèle de langage uniquement pour choisir une étiquette. Sabaki traite cela comme un problème de classification et le résout avec des modèles de quelques mégaoctets.

Mascotte shiba inu qui hausse les épaules, un point d’interrogation au-dessus de la tête
  1. Des réponses, pas des textes

    Sabaki n’écrit jamais de texte. Il répond à des questions typées : un choix parmi des options, un score ou une probabilité oui/non. Chaque réponse tient en une passe, donc aucun jeton à échantillonner et rien à analyser.

  2. Des greffons plutôt qu’un modèle géant

    Un routeur note les greffons par recouvrement de mots-clés et envoie le texte au meilleur. Chaque greffon est un paquet npm à part, entraîné, versionné et publié seul. C’est un mélange d’experts à l’échelle du système : une porte plus grossière qu’un entraînement conjoint, mais bien plus simple à exploiter.

  3. Assez petit pour tourner partout

    Nano est un classifieur TF-IDF de 20 à 650 Ko sans dépendance. Mini est un MiniLM affiné puis quantifié en ONNX int8, 22 Mo. Les deux tournent sur un CPU ordinaire, dans votre propre processus.

  4. Il sait quand il ne sait pas

    Un sujet inconnu renvoie null, jamais une supposition. Mini montre un doute sain hors distribution (0,2 à 0,5 de confiance sur des dragons, des recettes et des chaînes vides), ce qui rend sûre une règle comme « automatiser au-dessus de 0,8 ».

Comment une décision est prise

Sabaki suit le contrat System One défini par TypeSafe, où les modèles renvoient des réponses typées et des probabilités plutôt que du texte généré (documentation System One, en anglais).

Parcours d’une décision SabakiUn état et ses questions arrivent au routeur. Un greffon spécialiste gagnant répond avec nano ou mini. Quand le domaine est inconnu, le généraliste de repli répond. Les deux produisent des réponses typées, servies sur POST /v1/systemone. État et questionsun texte quelconque Routeurhits / sqrt(mots-clés) Greffon spécialistenano < 1 ms, mini ~20 ms Généraliste de replilit des questions libres Réponses typéeschoice, score, noul POST /v1/systemone un spécialiste gagne inconnu Parcours d’une décision SabakiUn état et ses questions arrivent au routeur. Un greffon spécialiste gagnant répond avec nano ou mini. Quand le domaine est inconnu, le généraliste de repli répond. Les deux produisent des réponses typées, servies sur POST /v1/systemone. État et questionsun texte quelconque Routeurhits / sqrt(mots-clés) Greffon spécialistenano < 1 ms, mini ~20 ms Généraliste de replilit des questions libres un spécialiste gagne inconnu Réponses typéeschoice, score, noul POST /v1/systemone
  1. Router

    Le routeur passe le texte en minuscules, retire les accents et compte les mots-clés trouvés pour chaque greffon. Le score est le nombre de correspondances divisé par la racine carrée du nombre de mots-clés. Sous le seuil du greffon (0,15 par défaut), le domaine est inconnu.

  2. Décider

    Le greffon gagnant répond avec nano (moins de 1 ms) ou mini (environ 20 ms). Si aucun spécialiste ne gagne, le cross-encoder généraliste optionnel répond à sa place, en lisant des questions définies à l’exécution.

  3. Répondre

    Vous obtenez des réponses typées avec leurs probabilités, au format Jev. Le champ model nomme le modèle qui a réellement répondu. En HTTP, c’est POST /v1/systemone.

Mascotte shiba inu qui oriente des enveloppes vers trois tunnels différents

Trois tailles de modèle, une seule interface

Tous les greffons parlent la même interface : commencez avec nano, puis passez un domaine en mini quand il demande plus de précision.

Minuscule chiot shiba inu debout sur une pièce, une plume sur le dos

nano TF-IDF et régression logistique

Poids
20 à 650 Ko
Latence
moins de 1 ms
Dépendances
aucune
Précision
0,34 à 0,90 par question

TypeScript pur, à parité exacte avec scikit-learn, vérifiée sur 20 questions. Il n’est pas autorégressif : une passe, aucun jeton généré.

Mascotte shiba inu avec une petite ceinture à outils et une loupe

mini MiniLM-L6, affiné par domaine

Poids
22 Mo, ONNX int8
Latence
10 à 25 ms
Dépendances
onnxruntime-node, optionnel
Calibration
ECE sous 0,16

Un modèle multitâche par domaine : un encodeur partagé et une tête linéaire par question. Les poids se téléchargent une fois depuis les releases de sabaki-models, sont vérifiés en SHA256 et mis en cache dans ~/.cache/sabaki.

Mascotte shiba inu lisant un parchemin de question ouverte

generalist Cross-encoder pour les questions ouvertes

Poids
22M de paramètres
Latence
20 à 36 ms
Dépendances
onnxruntime-node
Statut
mini servi (0,756 en val mix, R=0,616 phishing, 0,536 sur typed-decisions)

Répond à tout : vous passez des instructions et jusqu’à 8 options candidates à l’exécution. Il sert de repli quand aucun spécialiste ne gagne le routage, et ne passe jamais devant l’un d’eux.

Un mode base plus gros, pour les tâches difficiles, est en cours d’évaluation.

Quantification ONNX int8, mesurée

La quantification dynamique int8 réduit un modèle mini d’environ 90 Mo à 22 Mo. Sur le benchmark customer-service, elle a coûté 0,004 de précision et laissé la calibration identique ou meilleure. Chaque export est remesuré.

L’affinage a battu les raccourcis

Affiner tout l’encodeur donne 0,68, contre 0,65 pour un encodeur gelé avec des têtes MLP. Distiller un enseignant de 400M dans des embeddings gelés a été essayé, puis abandonné.

Comment les greffons sont entraînés

Un greffon nano

  1. Rassembler des paires (texte, étiquette) depuis des jeux de données publics ou vos propres exports.
  2. Découper de façon déterministe : un élément sur cinq part en test, stratifié dans le temps. Entraîner sur les premiers éléments seulement gonflait un score à 0,93, contre 0,52 hors découpage.
  3. Ajuster un TF-IDF (unigrammes et bigrammes, 3000 à 6000 caractéristiques) et une régression logistique. Arrondir les coefficients à 1e-4.
  4. Exporter vocabulaire, IDF et coefficients en JSON.
  5. Publier précision et ECE sur le jeu de test dans le README du greffon.

Un greffon mini

  1. Affiner MiniLM-L6 de bout en bout, 8 à 12 epochs à 2e-5 sur GPU CUDA, une tête par question.
  2. Exporter en ONNX et vérifier la parité exacte.
  3. Quantifier en int8, puis remesurer précision et ECE.

La confidentialité passe d’abord : anonymisez avant d’entraîner. Sur des e-mails, retirer tous les termes personnels du vocabulaire a coûté 0,024 de précision.

Greffons : un paquet npm par domaine

Chaque greffon embarque ses propres poids nano et son manifeste. Les quatre greffons du benchmark ont aussi un modèle mini affiné, ce qui montre jusqu’où va un petit spécialiste.

Mascotte shiba inu qui branche une prise en forme de pièce de puzzle dans une prise murale
Précision du modèle nano sur le jeu de test, avec le score mini quand il existe.
PaquetDécideQuestions et précisionPoids
@sabaki-js/customer-service Tickets de support
  • category 0,900 mini 0,91
  • needs_human 0,72
  • urgency 0,64
  • churn_risk 0,60
  • action 0,57
548 Ko
@sabaki-js/invoice-processing Factures, commandes et livraisons
  • duplicate 0,89 mini 0,89
  • matches_order 0,66
  • urgency 0,63
  • discrepancy_severity 0,55
  • disposition 0,52
20 Ko
@sabaki-js/security-incidents Tri des incidents de sécurité
  • true_positive 0,77
  • disposition 0,73 mini 0,76
  • credential_compromise 0,73
  • severity 0,63
  • urgency 0,57
476 Ko
@sabaki-js/agent-trace-observability Traces d’agents IA
  • needs_review 0,59 mini 0,82
  • risk 0,43
  • urgency 0,39
  • action 0,36
  • outcome 0,34
48 Ko
@sabaki-js/mail Tri d’e-mails en 8 catégories, plus soupçon de phishing. Le score de catégorie est 0,889 en test et 0,769 de bout en bout ; le soupçon est expérimental.
  • bucket 0,889
  • suspicious
655 Ko
@sabaki-js/doom Décisions de navigation et de combat dans Doom. En cours de développement.
  • command
  • target
  • weapon
5 Ko
@sabaki-js/plugin-template Point de départ pour votre propre greffon.

Écrire un greffon en quelques lignes

Un greffon, c’est un manifeste et une fonction classify. Le champ threshold fixe la part de mots-clés trouvés sous laquelle le routeur répond « inconnu ».

  • definePlugin : n’importe quelle logique, sans entraînement.
  • nanoClassifier : poids TF-IDF embarqués.
  • miniClassifier : un modèle ONNX téléchargé.
  • autoClassifier : mini s’il se charge, nano sinon.

Partir du modèle de greffon

import { definePlugin } from "sabaki";

const ping = definePlugin({
  manifest: { name: "ping", domain: "ping", version: "0.1.0", questions: ["up"], keywords: ["ping"] },
  classify: () => ({ decision: "pong", confidence: 1, domain: "ping" }),
});

Une boucle de jeu à 35 Hz sur un CPU

Pour prouver la latence, Sabaki joue à Doom. Le jeu tourne en Python (ViZDoom) et appelle un serveur de décision JavaScript à chaque tick. Mini sert environ 71 requêtes par seconde sur un thread et nano environ 18 000 : un tick à 35 Hz passe donc sur n’importe quel CPU. Avec une boussole de sortie, mini atteint la sortie du premier niveau dans 2 à 4 parties sur 6 ; nano n’y arrive jamais, car les états en texte perdent l’information spatiale. Comment ça joue : à chaque tick, les capteurs sérialisent le jeu en texte plus une ligne de compas ; le modèle répond command, target, weapon en HTTP ; un exécuteur scripté (waypoints A*, approche des portes, latch d’ouverture 15 ticks) convertit la commande en entrées Doom. Le modèle décide, l’exécuteur conduit. C’est un test de résistance, pas un produit.

Détails techniques du workflow
  1. Les capteurs lisent l'intérieur du moteur à chaque tick : labels, secteurs, positions.
  2. doomlib sérialise l'état en texte plus une ligne de compas (distance et cap de la sortie).
  3. Le modèle MiniLM répond command, target et weapon en HTTP (/v1/systemone).
  4. L'exécuteur scripté (waypoints A*, approche des portes, latch d'ouverture 15 ticks) convertit la commande en 14 entrées de jeu.
  5. Aucun modèle de vision sur ce chemin ; une tête SFT 1.1M joue depuis les pixels en arène. Pas de RL.

Voir la partie · @sabaki-js/doom

Benchmarks, compromis compris

Sur le benchmark typed-decisions, Sabaki cède quelques points de score pour une latence environ 1000 fois plus basse, mesurée face au modèle Laya de 421M sur CPU.

Score sur les jeux de test typed-decisions

  1. OpenDecider-nano 0,796 400M, GPU
  2. Laya typed-decisions 0,766 421M, CPU environ 25 s
  3. TypeSafe Jev 0,754 API uniquement
  4. sabaki mini 0,69 22M int8, environ 20 ms
  5. sabaki nano 0,61 TF-IDF, moins de 1 ms
  6. Laya base 0,362 421M, zero-shot

Latence CPU par décision, échelle logarithmique

  1. sabaki nano < 1 ms
  2. sabaki mini environ 20 ms
  3. sabaki generalist 20 à 36 ms
  4. Laya, 421M environ 25 s par état

Les scores d’OpenDecider-nano, Laya et Jev sont des chiffres publiés, non remesurés. Les 25 s de Laya viennent du test CPU d’un portage ONNX par les auteurs de Sabaki. Le généraliste servi (mini, 22,7M) obtient 0,536 sur le jeu de test typed-decisions (v4 : 0,29) ; son 0,756 est sa propre validation mix — il reste hors du graphique en attendant les chiffres v1.

Modèles de décision ouverts plus gros (144-151M), pour référence

Le généraliste sabaki fait 22,7M : environ 6,5x plus petit que le plus petit modèle listé ici, et le plus petit modèle de décision généraliste de la liste. Chiffres auto-déclarés ; protocoles différents.

Générations du généraliste (préliminaire)
GénérationVal mixRappel PhishNChipsTest typed-decisions
v40.848R=0.0260.29
v50.838R=0.066—
A (22M, 80k)0.898R=0.4060.546
mini v1.0.0 (served)0.756R=0.6160.536
B (144M, 80k, scratch)0.692R=0.0620.568
multi v8 (117M, non-latin fallback)0.554R=0.7360.31

Chiffres préliminaires pendant l'entraînement v6 : la val mix est propre à chaque run (non comparable entre lignes) ; PhishNChips (2 000 emails tenus) et le test typed-decisions sont identiques pour toutes les lignes. *sous-échantillon n=200.

Nano face à mini, par workflow
WorkflowQuestion principalenanomini
customer_servicecategory0,9000,91
invoice_processingduplicate0,8900,89
security_incidentsdisposition0,7300,76
agent_traceneeds_review0,5900,82

Split temporel (lots de génération séparés) : 300 états d’entraînement et 100 de test par workflow. Sur les e-mails, nano obtient 0,865 sans aucun terme personnel, et MiniLM ne fait qu’égaler TF-IDF (à 0,02 près) : c’est donc nano qui est livré.

Sabaki face aux autres approches

Face aux grands modèles de décisions typées, le compromis est quelques points de score contre un modèle qui tourne n’importe où.

SabakiGrands modèles de décisions typées
Taille du modèleQuelques Ko de poids (nano), 22M en int8 (mini)400M à 421M de paramètres (OpenDecider-nano, Laya)
Où il tourneN’importe quel CPU, dans votre processusUn GPU, ou une API hébergée (Jev)
Latence CPUMoins de 1 ms (nano), environ 20 ms (mini)Environ 25 s par état pour Laya
Score au benchmark0,61 (nano), 0,69 (mini)0,754 à 0,796
Coût par appelAucunTemps GPU ou frais d’API

Un LLM généraliste fait bien plus, et c’est lui qu’il faut utiliser pour du texte, du raisonnement ou des réponses ouvertes. Sabaki vise le cas étroit où il faut une étiquette en millisecondes, en local, avec une confiance sur laquelle fixer un seuil.

Greffons
Les experts de domaine sont des paquets séparés : vous n’installez que ceux vers lesquels vous routez.
Quantification ONNX int8
Un modèle mini est livré à environ un quart de sa taille d’origine, pour 0,004 de précision.
Modèles nano
Un classifieur de quelques kilooctets couvre les cas où un modèle plus gros n’apporte presque rien. Sur les e-mails, MiniLM égalait TF-IDF : nano est livré.

Article scientifique

La conception, les mesures et les compromis derrière Sabaki, rédigés comme un article scientifique.

Preprint v1 — octobre 2026

Sabaki: An Organizational Mixture-of-Experts for Typed Decisions on CPU

Fox3000foxy, chercheur indépendant

Les grands modèles de langage sont souvent sollicités pour des tâches qui relèvent de la classification. Sabaki remplace l’appel monolithique par un mélange d’experts organisationnel : un routeur sensible aux mots-clés et à la langue envoie chaque entrée vers un petit greffon classifieur indépendant (nano TF-IDF, moins de 1 ms ; mini MiniLM ONNX, environ 20 ms sur CPU ; ou un généraliste cross-encoder) qui renvoie une réponse typée avec confiance calibrée. Sur le split public typed-decisions, il obtient 0,61 (nano) et 0,69 (mini) contre 0,75 à 0,80 pour des modèles exigeant GPU ou API, pour une latence CPU en millisecondes au lieu d’allers-retours API (latences concurrentes jamais mesurées).

Lire le PDF (v1)

Citer
@misc{sabaki2026orgmoe,
  title  = {Sabaki: An Organizational Mixture-of-Experts for Typed Decisions on CPU},
  author = {Fox3000foxy},
  year   = {2026},
  note   = {Preprint v1, octobre 2026},
  url    = {https://sabaki.fox3000foxy.com/assets/paper/sabaki-organizational-moe-typed-decisions.pdf}
}

Démarrage rapide

Commencez avec nano. Il est synchrone, embarqué et n’a besoin de rien d’autre.

Nano

Enregistrez un greffon et appelez decide. Passez question pour poser une autre question que la principale.

npm i sabaki @sabaki-js/customer-service
import { Sabaki } from "sabaki";
import customerService from "@sabaki-js/customer-service";

const sabaki = new Sabaki().register(customerService);

const ticket =
  "Customer ticket: I was charged twice for my subscription, billing error on my account, please refund";

sabaki.decide({ state: ticket });
// { decision: "billing", confidence: 0.313, domain: "customer_service", plugin: "@sabaki-js/customer-service" }

sabaki.decide({ state: ticket, question: "needs_human" });
// { decision: "true", confidence: 0.783, ... }

Mini

Mini charge un modèle ONNX au premier usage et demande onnxruntime-node. Utilisez la voie asynchrone et un seuil de confiance.

npm i sabaki @sabaki-js/customer-service onnxruntime-node
import { Sabaki, miniClassifier } from "sabaki";
import customerService from "@sabaki-js/customer-service";

// Downloads the int8 ONNX model once, SHA256-verified, cached in ~/.cache/sabaki
const mini = await miniClassifier(customerService.manifest, "customer_service");
const sabaki = new Sabaki().register(mini);

const r = await sabaki.decideAsync({ state: ticket, question: "category" });
if (r.confidence > 0.8) automate(r);
else escalate(r);

Généraliste de repli

Le généraliste répond quand aucun spécialiste ne gagne le routage. Faites pointer SABAKI_GENERALIST_DIR vers un dossier contenant generalist.onnx et tokenizer/tokenizer.json. Il est encore en entraînement.

import { Sabaki, definePlugin, loadGeneralist } from "sabaki";
import mail from "@sabaki-js/mail";

const backend = loadGeneralist(process.env.SABAKI_GENERALIST_DIR);
const generalist = definePlugin({
  manifest: { name: "@sabaki-js/generalist", domain: "generalist", version: "0.1.0", questions: ["decision"], keywords: [] },
  classify: (input) => backend.decide(input),
});

const sabaki = new Sabaki().register(mail).setFallback(generalist);

// No specialist matches: the generalist answers your own question.
await sabaki.decideAsync({
  state: "The customer says the app deleted their data",
  question: "Is this urgent?",
  options: ["yes", "no"],
});

HTTP

Un serveur compatible Jev est fourni en exemple dans le dépôt. C’est un outil de développement : ajoutez une authentification avant de l’exposer.

git clone https://github.com/sabaki-js/sabaki && cd sabaki
npm install && npm run build
node examples/serve.mjs 8000
curl -s localhost:8000/v1/systemone \
  -H 'content-type: application/json' \
  -d '{"state":"Customer ticket: I was charged twice, please refund","questions":{"category":{"type":"choice"}}}'
Résultat
{
  "model": "sabaki-mini",
  "answers": {
    "category": { "type": "choice", "choice": "<label>", "probabilities": { "<label>": 0.0 }, "confidence": 0.0 }
  },
  "usage": { "input_tokens": 0, "output_tokens": 0 }
}

API hébergée

Pas envie de tout installer ? Pas de panique ! Nous hébergeons une instance gratuite, toujours à jour, ici même. Essayez avec le formulaire ci-dessous :

Ou appelez-la vous-même :

curl
curl -s https://sabaki-pi.vercel.app/api/systemone -H 'content-type: application/json' -d '{"state":"I want a pizza","questions":{"q":{"type":"choice","instructions":"Pick one.","options":["order food","taxes"]}}}'

Besoin de milliers de décisions, pas d’une seule ?

Bunkitsu résout des fichiers CSV entiers avec le même routeur et les mêmes greffons.

Voir comment Bunkitsu fonctionne

npx bunkitsu resolve entrees.csv --out resultats.csv --plugin ./mon-greffon

Ce qui n’est pas encore prêt

Le dépôt est franc sur ses lacunes, et cette page aussi.

Lire la feuille de route complète

  • Le généraliste en est à l’epoch 0 (score 0,56) et s’entraîne encore.

  • Un mode base plus gros, pour les tâches difficiles, est en cours d’évaluation.

  • Nano est le plus faible sur les traces d’agents (0,34 à 0,59). Mini porte needs_review à 0,82.

  • Les états Doom en texte plafonnent vers 0,57 : seule la navigation avec mini termine le niveau.

  • Les greffons du benchmark sont entraînés sur de l’anglais, et le greffon mail sur une boîte de réception en majorité française. Un entraînement multilingue est prévu en cas de demande.

  • Le serveur HTTP est un outil de développement. Ajoutez une authentification avant de l’exposer.

  • Prévu : le temperature scaling pour affiner la calibration, ainsi qu’un CLI et un hub de greffons (bunkitsu).

Questions fréquentes

Qu’est-ce que Sabaki ?

Sabaki est une bibliothèque TypeScript qui route un texte vers le bon petit greffon classifieur et renvoie une réponse typée (un choix, un score ou un oui/non) avec une confiance calibrée. Elle tourne sur un CPU, en millisecondes.

En quoi diffère-t-il d’un grand modèle de langage ?

Il ne génère pas de texte. Il répond à des questions typées en une seule passe : vous obtenez une étiquette et une confiance en environ 1 ms (nano) ou 20 ms (mini), sans rien à analyser. Utilisez un LLM pour du texte ou du raisonnement, et Sabaki pour une décision.

Faut-il un GPU ou une clé d’API ?

Non. Nano n’a aucune dépendance d’exécution. Mini passe par le paquet optionnel onnxruntime-node sur un CPU ordinaire. Il n’y a aucun coût par appel.

Quelle est sa précision ?

Sur le benchmark typed-decisions, mini obtient 0,69 et nano 0,61, contre 0,754 à 0,796 pour des modèles qui exigent un GPU ou une API. La confiance est calibrée (ECE sous 0,16 pour mini) : vous pouvez automatiser au-dessus d’un seuil comme 0,8 et escalader le reste.

Quelle différence entre nano, mini et le généraliste ?

Nano est un classifieur TF-IDF et régression logistique de quelques kilooctets. Mini est un MiniLM affiné puis quantifié en ONNX int8, 22 Mo. Le généraliste est un cross-encoder qui répond à des questions définies à l’exécution, utilisé en repli quand aucun spécialiste ne correspond.

Est-il compatible avec Jev et System One ?

Sabaki parle un sous-ensemble compatible Jev du contrat System One en HTTP : POST /v1/systemone, GET /health et GET /v1/models. Le champ model nomme le modèle qui a réellement répondu.

Puis-je écrire mon propre greffon ?

Oui. Un greffon est un manifeste et une fonction classify. Utilisez definePlugin pour n’importe quelle logique, nanoClassifier pour des poids TF-IDF, miniClassifier pour un modèle ONNX, ou partez du modèle de greffon.

Quelles langues sont prises en charge ?

Les quatre greffons du benchmark sont entraînés sur de l’anglais et le greffon mail sur une boîte de réception en majorité française. L’entraînement multilingue figure sur la feuille de route, en cas de demande.

Quelle est la licence ?

MIT. Les paquets sont publiés sur npm avec provenance via la publication de confiance, et tout s’exécute en local : vos textes restent chez vous.

Éditeur : sabaki-js. Hébergement : Cloudflare, Inc. Ce site ne collecte aucune donnée personnelle : ni comptes, ni cookies, ni mesure d'audience, ni scripts tiers.