Alternativa a NVIDIA Auto-Ontology

L'alternativa a NVIDIA Auto-Ontology con verifica simbolica

Auto-Ontology controlla l'SQL di un modello con altre chiamate al modello. In SynaLemma un verificatore simbolico dimostra ogni regola ben formata, sicura e che termina prima che giri qualsiasi SQL.

SynaLemma

SynaLemma vs Auto-Ontology: differenze principali

  1. Ogni regola dimostrata prima dell'esecuzione

    In Auto-Ontology, modelli linguistici controllano e correggono l'SQL scritto da un altro modello. Un verificatore simbolico dimostra che ogni regola è ben formata, sicura e termina, e rifiuta una regola non valida con il motivo, prima che venga eseguito qualsiasi SQL. Asserzioni del primo ordine restituiscono le righe che le violano.

  2. Stessa regola, stesso SQL

    In Auto-Ontology, un modello scrive l'SQL per ogni domanda. In SynaLemma l'agente non scrive mai SQL: il motore lo compila a partire dalla regola, quindi una regola dà sempre lo stesso SQL. Ogni numero cita la sua regola, che il vostro team può leggere, correggere o bloccare.

  3. Ragiona il motore, non il modello

    Auto-Ontology non documenta alcun motore di regole: join e totali sono qualunque SQL scriva il modello. In SynaLemma il modello traduce la domanda in una regola, e il motore Synalog calcola ogni join, ricorsione e totale, fino a una profondità dichiarata, con terminazione verificata, compilando in SQL.

  4. Una definizione per termine

    Ogni termine aziendale è definito una volta, come concetto o regola sulle vostre tabelle, e ogni persona e ogni agente usa quella definizione. Le definizioni si costruiscono l'una sull'altra invece di essere ripetute.

  5. Ogni accesso delimitato, ogni modifica registrata

    L'agente non può aggirare il layer: non scrive SQL, l'SQL grezzo viene rifiutato prima dell'esecuzione, e agisce solo con i permessi della persona che chiede. Ogni modifica a una definizione è un commit git con il suo autore, verificabile e reversibile.

  6. Sovrano per costruzione, non per contratto

    Dati, regole e modello restano sulla vostra infrastruttura. Il motore compila l'SQL, quindi basta un piccolo modello aperto, senza costi per token. Il motore Synalog è open source, con licenza Apache-2.0.

Synalog

Esempio: un'asserzione che rileva un cliente mancante

Il fatturato per cliente, con tre asserzioni. Il cliente 12 manca dalla tabella dei clienti; il motore indica la riga.

shop.l
Order(order_id:, customer_id:, amount:, status:) :- orders(order_id:, customer_id:, amount:, status:);
Customer(customer_id:, country:) :- customers(customer_id:, country:);

@Assert(Revenue,
      one_row_per_customer: "∀ c r s, Revenue c r → Revenue c s → r = s",
      known_customer:       "∀ c r, Revenue c r → ∃ k, Customer c k",
      positive:             "∀ c, Revenue c > 0");
Revenue(customer_id:, revenue? += amount) distinct :-
  Order(customer_id:, amount:, status: "delivered");
$ synalog shop.l verify
✓ Revenue.one_row_per_customer holds ✗ Revenue.known_customer is violated: ∀ c r, Revenue c r → ∃ k, Customer c k 1 counterexample: +----+----+ | c | r | +----+----+ | 12 | 20 | +----+----+ 1 row ✓ Revenue.positive holds
In sintesi

SynaLemma vs NVIDIA Auto-Ontology in sintesi

SynaLemma vs NVIDIA Auto-Ontology in sintesi
CriterioSynaLemmaNVIDIA Auto-Ontology
Semantico: una definizione per termine Definizioni che si basano l'una sull'altra: ogni termine aziendale definito una volta, come regola sulle vostre tabelle, riutilizzato da ogni persona e ogni agente Termini, attributi SQL e relazioni redatti da un modello, certificati da persone
Ragionamento: chi calcola join, ricorsione, totali Il motore, non il modello: Synalog calcola ogni join e ricorsione, fino a una profondità dichiarata, compilati in SQL Un modello scrive l'SQL dai termini recuperati; nessun motore di regole documentato
Verificato: cosa si controlla prima che una regola giri Ogni regola dimostrata ben formata, sicura e che termina; asserzioni del primo ordine restituiscono le righe che le violano Chiamate al modello controllano i valori dei filtri e la query, correggendo l'SQL in caso di errore
Deterministico: stessa regola, stesso SQL Mai generato a ogni domanda: SQL compilato dal motore a partire dalla regola; definizioni riutilizzate e bloccabili SQL scritto da un modello a ogni domanda; attributi SQL certificati riutilizzati
Governato: controllo di accessi e modifiche L'agente non può aggirare il layer: nessun SQL scritto, SQL grezzo rifiutato, solo il ruolo di chi chiede; ogni modifica è un commit git Accesso con Better Auth e RBAC; gli strumenti MCP girano con i permessi di ogni utente
Modello linguistico Quello che scegliete voi: basta un piccolo modello aperto, senza costi per token Modelli Nemotron, tramite l'API ospitata di NVIDIA per impostazione predefinita, o qualsiasi endpoint compatibile con OpenAI
Deployment On-premise, sulla vostra infrastruttura Self-hosted: un chart Helm su Kubernetes, o Docker Compose
Linguaggio delle definizioni Synalog, un linguaggio logico open source con un compilatore Termini, corrispondenze di colonne ed espressioni SQL, salvati in Postgres e pgvector
Database PostgreSQL, BigQuery, Databricks, Trino, Presto, DuckDB, SQLite Dieci motori, tra cui PostgreSQL, MySQL, Databricks, Snowflake, Trino e DuckDB
NVIDIA Auto-Ontology

Perché i team cercano un'alternativa ad Auto-Ontology

  • Un modello scrive l'SQL per ogni domanda

    Il glossario lo guida; la query può cambiare ogni volta (README).

  • Chiamate al modello controllano l'SQL

    Controlli e correzioni sono affidati a modelli linguistici, che possono sbagliare entrambi nello stesso modo.

  • Nessun motore di regole

    Non ne è documentato nessuno: nessuna ricorsione, nessun ragionamento sul tempo, nessuna asserzione sui dati.

  • Un glossario, non un programma

    Termini, mappature di colonne e frammenti SQL salvati in Postgres e pgvector.

Domande frequenti

Alternativa ad Auto-Ontology: domande frequenti

Qual è la differenza tra SynaLemma e NVIDIA Auto-Ontology?

In Auto-Ontology un modello scrive l'SQL per ogni domanda. SynaLemma compila l'SQL da regole verificate, controllate da un verificatore simbolico.

Basta controllare l'SQL con un secondo modello?

No. Due sistemi probabilistici possono sbagliare nello stesso modo. Un verificatore simbolico dimostra che ogni regola è ben formata, sicura e termina, qualunque cosa abbia scritto il modello.

SynaLemma richiede modelli di frontiera?

No. Basta un piccolo modello aperto sul vostro hardware.

Guardatelo sui vostri dati

Portate una domanda a cui il vostro stack attuale non sa rispondere.

In 30 minuti vi mostriamo SynaLemma che risponde, con la regola dietro il numero e i controlli che ha superato.