SynaLemma

Un ragionamento davvero verificabile, perché non è il modello a farlo.

Gli altri sistemi ad agenti affidano il ragionamento al modello linguistico. SynaLemma è un layer semantico e di ragionamento costruito al contrario: il modello traduce la vostra domanda in una regola, e un motore logico svolge il ragionamento. Verifica formalmente la regola, ricava la risposta nel database che usate già e conserva la regola, così ogni passaggio può essere letto e rieseguito.

Architettura

Il modello propone. Il motore logico ragiona.

La maggior parte dei sistemi ad agenti mette il modello linguistico al centro e lo lascia ragionare fino a una risposta. SynaLemma lo mette ai margini. Il modello propone una regola, e il motore esegue ogni join, ricorsione e totale. Nulla arriva ai vostri dati o alla vostra risposta senza passare dal motore.

L'approccio abituale
  1. La vostra domanda
  2. Modello linguistico
  3. SQL indovinato
  4. Il vostro database
  5. Modello linguistico
  6. Una risposta plausibile
Il modello ragiona in testo. La sua “spiegazione” è scritta a posteriori e non registra il modo in cui la risposta è stata calcolata, quindi non c'è nulla da rieseguire. Un log delle azioni dell'agente è un registro, non una prova. Cosa mostra la ricerca →
Fuori da SynaLemma
Modello linguistico Locale o in hosting. Propone regole; decide il motore.
Synalinks L'agenteGuida il modello passo dopo passo e traccia tutto.
Synalog Il motore logico
  • verifica ogni regola
  • svolge il ragionamento
  • compila la regola in SQL
  • controlla il risultato
Semantic Layers La conoscenzaRegole verificate, come file in git.
I vostri team e agenti L'app, Slack o Teams, MCP e Agent2Agent.
Il vostro database Esegue l'SQL. Interrogato sul posto.
Il vostro repository git Cronologia, revisione, audit, ripristino.
Modello linguistico ⇄ Synalinks proposta richiesta vincolata
Synalinks ⇄ Synalog regola da verificare rifiuto e motivo, oppure righe
Synalog ⇄ Semantic Layers regola conservata regola riutilizzata
Synalinks ⇄ I vostri team e agenti la risposta e la sua regola domanda
Synalog ⇄ Il vostro database SQL verificato righe
Semantic Layers ⇄ Il vostro repository git ogni modifica è un commit

Il modello traduce la vostra domanda in una regola e formula la risposta. Ogni inferenza nel mezzo è del motore, e può essere rieseguita.

  • Parte di SynaLemma
  • Esterno, collegato a SynaLemma
  • Ciò che passa, nella direzione della freccia
Tracce e prove

Una traccia è un registro, non una prova.

Il ragionamento che un modello linguistico scrive è altro testo che ha generato, e la ricerca continua a mostrare che può tacere ciò che ha davvero determinato la risposta.

Registrare le azioni di un agente ha lo stesso limite: il log dice quali strumenti sono stati chiamati, non se la risposta regge, e la stessa domanda posta di nuovo può seguire un altro percorso.

SynaLemma conserva sì una traccia, ma solo per il debug. La prova è il codice logico: una regola Synalog che ha superato il verificatore formale prima di essere eseguita, che chiunque può leggere e che, rieseguita sugli stessi dati, restituisce le stesse righe.

Cosa mostra la ricerca

  1. Post-Hoc Reasoning in Chain of Thought: Decoding and Steering Pre-Committed Answers Cox et al., 2026 · preprint

    La risposta del modello si legge nel suo stato interno prima che scriva qualsiasi ragionamento, e modificare quello stato ribalta spesso la risposta: il ragionamento arriva spesso dopo la decisione.

  2. Two Regimes of Chain-of-Thought Unfaithfulness: Metric-Based Detection Fails Where Models Are Wrong Angdembay et al., 2026 · preprint

    La maggior parte del ragionamento infedele accompagna risposte sbagliate, ed è proprio lì che nessun metodo di rilevamento testato fa meglio del caso.

  3. Reasoning Models Don't Always Say What They Think Chen et al., Anthropic, 2025

    I modelli di ragionamento usano suggerimenti ricevuti e spesso non lo dicono.

  4. From Agent Traces to Trust: A Survey of Evidence Tracing and Execution Provenance in LLM Agents Wang et al., 2026 · preprint

    Un log registra ciò che è accaduto, ma può non mostrare se le evidenze sostenevano un'affermazione: dice che cosa è successo, non che cosa dipendeva da che cosa.

Anatomia

Tre motori e un prodotto, tutti scritti da noi.

Ogni layer ha un compito e passa al successivo qualcosa che quest'ultimo può controllare. Tre di essi sono open source; il quarto è il prodotto che li assembla.

Il prodotto

  1. SynaLemma L'harness

    Ciò che usa il vostro team: Lemma, l'assistente; tabelle, concetti e regole che potete leggere e modificare; il grafo di cosa dipende da cosa; ruoli, cronologia e i canali in cui già comunicate.

Open source · Apache-2.0

  1. Synalinks L'agente

    Guida il modello passo dopo passo: cerca le definizioni esistenti, scompone la domanda, scrive regole, chiama strumenti. Gli output sono vincolati a uno schema, il modello è sostituibile e ogni passaggio è tracciato.

  2. Synalog La logica

    Verifica ogni regola prima che esista qualsiasi SQL, la compila nel dialetto SQL del vostro database e controlla sui vostri dati ciò che il suo risultato deve rispettare.

  3. Semantic Layers La conoscenza

    Dove risiedono le definizioni: un file leggibile per ogni tabella, concetto o regola, in un repository git. Un layer si revisiona come il codice e può essere installato in un altro progetto.

Fuori da SynaLemma

  • Il vostro database tabelle invariate, nomi reali, nessuna copia
  • Il vostro modello locale o in hosting, sostituibile
  • Parte di SynaLemma
  • Esterno, collegato a SynaLemma
Il prodotto

Che cosa vede il vostro team.

Il ciclo

Che cosa succede tra la vostra domanda e la risposta.

  • Cercare

    L'agente cerca nel layer una definizione che risponde già alla domanda. Un layer di migliaia di definizioni non entra mai per intero nel contesto del modello: entra solo ciò che corrisponde.

  • Scrivere

    Se nessuna è adatta, ne scrive una, partendo dai concetti già presenti invece che dalle tabelle grezze.

  • Verificare

    La regola passa dal verificatore formale. Se non supera la verifica, viene rifiutata con il motivo, e nulla viene salvato se l'intero layer non resta coerente.

  • Eseguire

    La regola verificata viene compilata in SQL ed eseguita nel vostro database. Le sue asserzioni vengono controllate sugli stessi dati.

  • Rispondere

    Solo allora l'assistente risponde, riportando le righe restituite dall'esecuzione e citando la regola, che potete aprire.

  • Conservare

    La regola viene salvata nel layer con un commit, con autore e data. La domanda successiva parte da lì.

Verificato dalla logica

Due controlli. Nessuno dei due è svolto da un modello.

Chiedere a un secondo modello di controllare il primo aggiunge soltanto un'altra opinione. SynaLemma controlla invece con la logica. È il primo e unico sistema di IA che scrive le proprie regole, le verifica formalmente e confronta i loro risultati con enunciati matematici.

La definizione, prima dell'esecuzione

Il verificatore formale di Synalog esamina ogni regola prima che venga generato qualsiasi SQL, senza coinvolgere il database: variabili mai legate, negazione e aggregazione non sicure, negazione attraverso la ricorsione, ricorsione senza caso base né limite, colonne, funzioni e predicati sconosciuti. Più di quindici classi di errore, segnalate tutte insieme. Una regola che non supera la verifica non viene mai salvata né eseguita.

Il suo risultato, sui vostri dati

Un'asserzione enuncia ciò che un risultato deve rispettare, indipendentemente da come viene calcolato: un componente compare una sola volta, una giacenza non è mai negativa, le consegne in ritardo non superano mai le consegne. È scritta in logica del primo ordine (∀, ∃, →, somme e confronti) come proposizione Lean, la notazione del dimostratore di teoremi Lean. Synalog compila in SQL una ricerca di controesempi e la esegue sul vostro database. In SynaLemma un'asserzione violata compare sulla regola, e le righe che la violano sono a un clic di distanza.

Un'asserzione violata indica che cosa la viola: qui, due fornitori sotto il livello di servizio concordato
counterexamples
✗ OnTimeDelivery.meets_service_level is violated:
  ∀ s r d t, OnTimeDelivery s r d t → t ≥ 0.6
  2 counterexamples:
+-------------------+------+----+-------+
| s                 | r    | d  | t     |
+-------------------+------+----+-------+
| Shenzhen VoltPack | high | 34 | 0.588 |
| Hsinchu Controls  | high | 47 | 0.553 |
+-------------------+------+----+-------+
Deterministico

Stessa regola, stesso SQL.

Chiedete due volte la stessa query a un modello linguistico e l'SQL può cambiare. In SynaLemma il modello non scrive mai SQL: il motore lo compila da una regola. Una volta scritta una definizione, ogni domanda che la usa ottiene la stessa query, chiunque la ponga.

01

Compilato, non generato

Synalog compila ogni regola nel dialetto SQL del vostro database. La stessa regola produce la stessa query a ogni esecuzione, su ogni canale, per ogni persona e ogni agente.

02

Riutilizzata prima di scriverne una

L'agente cerca nel layer prima di scrivere qualsiasi cosa. Una domanda coperta da una definizione esistente riceve la risposta di quella definizione, non di un nuovo tentativo.

03

Bloccata una volta consolidata

Quando il vostro team concorda una definizione, bloccatela: nessun agente può più modificarla. Rieseguite qualsiasi risposta dalla sua regola e ottenete le stesse righe dagli stessi dati.

Ciò che può variare: come l'assistente formula la risposta, e la regola che propone per una domanda che nessuna definizione copre ancora. Quella regola viene verificata e vi viene mostrata, e una volta conservata resta fissa.

Governato

Ogni accesso delimitato, ogni modifica registrata.

Fare l'audit di un'IA di solito significa leggere i log di ciò che un modello ha detto. In SynaLemma l'audit riguarda due registrazioni esatte: la derivazione, svolta dal motore logico, e la cronologia delle regole, conservata in git, lo strumento che i team software usano già per tracciare ogni modifica. E nessuno, persona o agente, raggiunge i vostri dati se non attraverso quelle regole, con i diritti del proprio ruolo.

01

Dalla risposta alle righe

Ogni numero cita la sua regola e la riga da cui proviene. Ogni regola indica i concetti su cui si basa, e ogni concetto le tabelle che legge. Potete seguire la catena o rieseguirne qualsiasi anello.

02

Dalla regola alla sua cronologia

Un layer semantico e di ragionamento è un repository git: un file per ogni tabella, concetto e regola. Ogni modifica è un commit attribuito al suo autore, che sia una persona, Lemma o un altro agente, con le differenze e la possibilità di tornare indietro.

03

Delimitato, e revisionato come il codice

Quattro ruoli e permessi per persona, e Lemma riceve solo gli strumenti di chi pone la domanda. Com'era questa definizione il giorno in cui quel numero è stato comunicato? Chi l'ha modificata, e quando? Confrontate due versioni, ripristinatene una o sottoponete una modifica alla stessa revisione di qualsiasi altro codice.

La cronologia registra le vostre definizioni e come sono cambiate, non i vostri dati: le righe restano nel vostro database.

I vostri sistemi esistenti

Funziona sui sistemi che usate già.

Un layer semantico classico è un progetto di modellazione che richiede mesi ed è superato poco dopo la consegna. SynaLemma scrive il layer man mano che vengono poste le domande, sopra i vostri database esistenti.

Nessun ETL, nessun secondo data warehouse

Le regole vengono compilate in SQL ed eseguite dove si trovano i dati. Su un database che gestite voi, SynaLemma dichiara le tabelle che scegliete e non le modifica mai. Basta un account in sola lettura.

Le tabelle così come sono

Gli schemi più vecchi mantengono i loro nomi reali di tabelle e colonne, spazi e accenti compresi. Il layer dà loro un significato senza toccarli.

Un grafo della conoscenza, senza database a grafo

Entità e relazioni vengono modellate sulle vostre tabelle relazionali. Il grafo è virtuale: viene compilato in SQL.

Domande difficili in SQL

Distinte base a ogni livello, catene gerarchiche, “quali assiemi si fermano se questo fornitore non consegna”: ricorsione fino a una profondità che dichiarate voi, quindi termina sempre, e ragionamento nel tempo.

Database a cui SynaLemma si collega
  • PostgreSQL
  • BigQuery
  • Databricks
  • Trino
  • Presto
  • DuckDB
  • SQLite

E i vostri file: CSV, Excel, JSON, JSONL, Parquet.

Nel prodotto

Tutto ciò che ottiene il vostro team.

Il layer vi appartiene. Tutto ciò che l'assistente scrive può essere letto, corretto e bloccato da una persona.

Lemma, l'assistente

Chiedere

  • Ogni numero citato con una menzione cliccabile, fino alla riga da cui proviene.
  • La vedete lavorare passo dopo passo: che cosa ha cercato, scritto ed eseguito.
  • Domande suggerite a partire dal vostro layer.
  • Messaggi vocali, trascritti sul vostro server.
  • Davanti a una richiesta aperta propone prima di agire, e chiede chiarimenti quando una domanda è ambigua.
  • “Spiega” e “Correggi” su qualsiasi regola, con un clic.
Tabelle

I vostri dati

  • Importazione di file CSV, Excel, JSON, JSONL, Parquet e SQLite, con il drag and drop.
  • Collegamento a un database, scegliendo quali tabelle esporre.
  • Copia di tabelle da un altro database in un'unica operazione, senza scrivere nulla sulla sorgente.
  • Un editor in stile foglio di calcolo con colonne tipizzate, ordinamento, ricerca, annulla e ripeti.
  • Esportazione di qualsiasi tabella o risultato in CSV o Excel.
  • Blocco delle righe di una tabella, o protezione della sua struttura.
Concetti, Regole, Memoria

La vostra conoscenza

  • Ogni regola mostrata come diagramma di flusso per chi non legge il codice, e come codice per chi lo legge.
  • Modifica di una regola sul posto: viene verificata al salvataggio, e un rifiuto ne indica il motivo.
  • Validata, non validata, bloccata: lo stato di ogni definizione è visibile.
  • Memoria: il grafo di cosa dipende da cosa, tra tabelle, concetti e regole.
  • Asserzioni con il loro stato, e le righe che le violano.
  • Cronologia con le differenze, e ripristino di qualsiasi versione.
Conoscenza riutilizzabile

Layer

  • Installazione di un layer pronto da un repository git o da uno zip. Nulla viene conservato se non supera la verifica sul vostro database.
  • Lavoro su più layer contemporaneamente.
  • Esportazione di un layer come semplici file: nessuna connessione, nessun segreto, nessuna riga.
  • Un layer è una cartella che funziona con gli strumenti open source di Synalog, con o senza di noi.
Oltre l'app

Agenti e automazione

  • Un server MCP fornisce a Claude Code, Codex, Cursor, VS Code Copilot o Windsurf gli stessi strumenti che usa Lemma.
  • Un endpoint Agent2Agent permette a un altro agente di interrogare Lemma direttamente.
  • Slack, Microsoft Teams, Discord, Telegram o WhatsApp, tramite un bot di vostra proprietà.
  • Loop: la stessa domanda a intervalli programmati, come la revisione delle carenze del lunedì o un controllo qualità giornaliero, pubblicata in una chat.
  • Un SDK per plugin, per aggiungere pagine e funzionalità vostre.
Controllo

Amministrazione

  • Quattro ruoli (admin, editor, analyst, viewer) e permessi per singola persona. Lemma riceve solo gli strumenti consentiti dal ruolo di chi pone la domanda.
  • Organizzazioni, ciascuna con il proprio storage.
  • Scelta del modello da un catalogo, test della connessione, cambio quando volete. Modelli locali: nessuna chiave API, nessun costo per token.
  • Ogni passaggio dell'agente, chiamata a uno strumento e chiamata al modello tracciati, presso di voi.
  • Credenziali e token conservati in forma cifrata.
  • Interfaccia in inglese, francese, olandese, italiano e spagnolo.
Sovranità

Sovrano per costruzione, non per contratto.

La maggior parte delle promesse di sovranità riguarda un luogo di hosting. Quella di SynaLemma riguarda l'architettura: il layer è progettato perché basti un piccolo modello aperto, così l'intero sistema, dal modello alle definizioni, gira in casa vostra. Se scegliete invece un modello in hosting, le vostre domande e gli estratti di dati necessari per rispondere vanno a quel fornitore, e a nessun altro.

Il vostro modello

Un modello aperto sul vostro hardware (Ollama, vLLM, LM Studio). Il modello si limita a proporre regole: il motore ragiona, un rifiuto dice esattamente cosa correggere e il contesto resta ridotto, quindi basta un modello piccolo. Gli harness generalisti per agenti sono tarati sui più grandi modelli proprietari.

I vostri dati

Interrogati sul posto, tramite un account che deve solo leggere: nessuna copia, nessuna pipeline, nessun cloud nel mezzo. Le credenziali sono cifrate e i messaggi vocali vengono trascritti sul vostro server.

Le vostre regole

Semplici file in un linguaggio aperto, nel vostro repository git. Girano anche con i soli strumenti open source: se smettete di lavorare con noi, le vostre definizioni restano vostre.

La vostra base

Motori pubblicati sotto Apache-2.0, scritti da un team con sede nell'Unione europea e installati da partner certificati sulla vostra infrastruttura.

Confronti

Che cosa distingue SynaLemma dalle alternative.

Anche altri progetti danno ai dati un layer semantico. La differenza sta in ciò che quel layer può esprimere, e in ciò che lo verifica.

Come si confrontano SynaLemma e Synalog con NVIDIA Auto-Ontology?

Entrambi pongono un layer semantico tra gli agenti di IA e i vostri database. Differiscono per che cosa sia quel layer e per che cosa lo verifichi.

In Auto-Ontology, il layer è un glossario di termini, corrispondenze di colonne e frammenti SQL memorizzati in un database. Al momento della domanda viene recuperato e passato a un modello linguistico come indicazione, e il modello scrive un nuovo SQL per ogni risposta. Una seconda chiamata al modello giudica poi se quel SQL è corretto. Un sistema probabilistico che ne controlla un altro non offre alcuna garanzia: entrambi possono sbagliare nello stesso modo.

In SynaLemma, il layer è un programma Synalog: concetti e regole compilati in modo deterministico in SQL. La verifica è affidata a un sistema simbolico, non a un modello. Prima che venga eseguito qualsiasi SQL, il verificatore dimostra che ogni regola è ben formata, sicura e termina, e rifiuta ogni regola che non lo sia. Le asserzioni scritte in logica del primo ordine vengono controllate sui vostri dati, e un'asserzione violata torna con i suoi controesempi. La stessa regola compila sempre nella stessa query, e ogni risposta risale, attraverso regole con un nome, fino alle vostre tabelle.

Synalog esprime anche ciò che un elenco di frammenti SQL non può esprimere: regole costruite su altre regole, ricorsione (gerarchie, catene a più passaggi), relazioni tra concetti e ragionamento nel tempo. È questo rigore a dare senso alla verifica: un file YAML a tipizzazione debole ha troppa poca struttura perché una dimostrazione possa dire qualcosa.

Synalog è un vero linguaggio di programmazione, e richiede più impegno per impararlo di un file YAML. Non dovete scriverlo voi: l'harness di analisi di SynaLemma scrive e mantiene le regole, e il verificatore controlla il suo lavoro prima che arrivi ai vostri dati. Abbiamo ottimizzato noi stessi questo harness, con il machine learning e il nostro framework open source Synalinks, perché l'analista funzioni con modelli locali sul vostro hardware, senza costi per token. Senza un harness messo a punto in questo modo, i team ripiegano sui modelli di frontiera e pagano ogni domanda. E poiché le risposte nascono da regole compilate e non da SQL generato a ogni domanda, un modello più piccolo arriva più lontano.

Leggi il confronto completo

Come si confrontano SynaLemma e Synalog con Apache Ossie?

Risolvono problemi diversi. Ossie è un formato di file: una specifica YAML neutrale rispetto ai fornitori, in incubazione presso la Apache Software Foundation, per scambiare dataset, metriche e join tra strumenti di BI e di analisi. Non esegue query. Ogni strumento che legge un file Ossie decide come tradurlo in SQL, e l'SQL di ciascun database va scritto a mano nel file.

Synalog è un linguaggio con un compilatore. Uno stesso programma compila in SQL per PostgreSQL, BigQuery, Databricks, Trino, Presto, DuckDB e SQLite, e la stessa regola compila sempre nella stessa query.

La differenza si vede in ciò che ciascuno può esprimere. Nella specifica di base di Ossie (una specifica di ontologia in bozza aggiunge concetti derivati e relazioni ricorsive), una metrica non può fare riferimento a un'altra metrica, un campo non può fare riferimento a un altro campo, un dataset non può basarsi su un altro dataset, e ogni relazione è una chiave esterna molti-a-uno. Il tempo è solo un indicatore su una colonna. In Synalog, le regole si costruiscono su altre regole, così le definizioni si accumulano invece di ripetersi. Gestisce anche la ricorsione (gerarchie, catene a più passaggi), le relazioni tra concetti e il ragionamento nel tempo.

Si vede anche in ciò che si può verificare. Un file Ossie può essere validato rispetto al suo schema e ai suoi riferimenti. Un programma Synalog è controllato da un verificatore simbolico, che dimostra prima di eseguire qualsiasi SQL che ogni regola è ben formata, sicura e termina. Le asserzioni scritte in logica del primo ordine vengono controllate sui vostri dati, con controesempi quando falliscono. Per gli agenti, Ossie offre indicazioni in testo libero (ai_context) che un modello può leggere. L'analista di SynaLemma scrive regole Synalog, e il verificatore le controlla prima che tocchino i vostri dati.

SynaLemma serve per definizioni che devono essere calcolate, verificate ed estese da agenti, non solo scambiate tra strumenti.

Leggi il confronto completo

Come si confrontano SynaLemma e Synalog con gli strumenti del web semantico (RDF, OWL, SHACL)?

Entrambi descrivono il significato dei dati con concetti e relazioni, ed entrambi ragionano su di essi. Ma sono costruiti per compiti diversi. Il web semantico descrive un dominio perché le ontologie possano essere pubblicate, condivise e collegate tra organizzazioni. Synalog descrive ontologie operative: solo i concetti e le relazioni che i vostri dati contengono davvero, ciascuno definito a partire dalle vostre tabelle e calcolato da esse.

Questo cambia la logica. OWL lavora sotto l'ipotesi del mondo aperto: un fatto assente dal grafo è sconosciuto, non falso, quindi OWL da solo non può verificare che ogni ordine abbia un cliente. SHACL esiste per colmare questa lacuna, come secondo linguaggio che valida i dati. Synalog è a mondo chiuso, come il vostro database: ciò che non è nei dati è falso. Regole, query e vincoli si scrivono in un unico linguaggio, e le asserzioni controllano direttamente i vostri dati, con controesempi quando falliscono.

Cambia anche lo stack. Un'implementazione del web semantico combina di solito RDF per i dati, OWL per l'ontologia, SHACL per la validazione e SPARQL per le query, più un triplestore o un linguaggio di mappatura come R2RML per raggiungere le tabelle relazionali. Synalog è un unico linguaggio che compila in SQL e gira sui database che avete già.

Più semplice non vuol dire meno ragionamento. Uno stesso programma Synalog può combinare ricorsione, aggregazione, negazione e ragionamento nel tempo, e un verificatore simbolico dimostra, prima dell'esecuzione, che ogni regola è ben formata, sicura e termina. I reasoner OWL classificano concetti; non calcolano i totali, le medie e le classifiche di cui ha bisogno la maggior parte delle domande di business.

Synalog è anche costruito per gli agenti. I suoi programmi sono abbastanza brevi perché un modello li scriva e abbastanza leggibili perché una persona li rilegga, e l'analista di SynaLemma li scrive man mano che arrivano le domande, ciascuno controllato dal verificatore prima che tocchi i vostri dati. Le ontologie del web semantico vengono di solito modellate in anticipo, da specialisti: un progetto che richiede comunemente mesi, spesso anni, e un budget consistente prima di rispondere alla prima domanda. Con SynaLemma, il layer si costruisce fin dalla prima domanda.

SynaLemma risponde alle domande sui vostri dati, con risposte che potete verificare, senza un progetto di modellazione preliminare.

Leggi il confronto completo

Come si confrontano SynaLemma e Synalog con Cube?

Cube è un layer semantico e un'API, in YAML o JavaScript: cubi, viste, misure, dimensioni e join, con cache e pre-aggregazioni su molti database. Come Synalog, compila le query a partire dal suo modello prima che raggiungano il data warehouse, quindi la differenza non sta lì. Sta in ciò che il modello può esprimere, e in ciò che lo verifica.

In Cube, ogni join è un LEFT JOIN, e le gerarchie sono livelli di esplorazione, non ricorsione. Catene gerarchiche, distinte base o dipendenze su più passaggi non trovano posto nel modello: richiedono una query SQL ricorsiva scritta a mano, così difficile da scrivere correttamente che quasi nessuno la scrive. In Synalog, l'attraversamento dei grafi fa parte del linguaggio: un caso base e un passo ricorsivo, con terminazione verificata, che girano su ogni motore.

Cube verifica che un modello compili, e la sua stessa documentazione avverte che un modello che compila può comunque restituire risultati sbagliati. Le risposte del suo agente sono misurate con valutazioni rispetto a query di riferimento. Synalog dimostra che ogni regola è ben formata, sicura e termina, e controlla i dati con asserzioni scritte in logica, con controesempi quando falliscono.

L'agente di IA di Cube fa parte di Cube Cloud e scrive Cube SQL a partire dalla vostra domanda, con modelli ospitati per impostazione predefinita; usare un vostro modello è un'opzione del piano Enterprise. L'analista di SynaLemma funziona con un piccolo modello aperto, sulla vostra infrastruttura.

SynaLemma è pensato per le domande a cui un'API con cache per dashboard non sa rispondere: quelle che richiedono ragionamento, con risposte che potete verificare.

Leggi il confronto completo

Come si confrontano SynaLemma e Synalog con il dbt Semantic Layer?

Il dbt Semantic Layer, basato su MetricFlow, definisce metriche in YAML sopra i modelli dbt e compila in SQL le query sulle metriche. Le differenze stanno nell'espressività, nei controlli e in ciò che un agente può raggiungere.

MetricFlow offre un catalogo fisso di tipi di metriche (semplice, rapporto, derivata, cumulativa, conversione), senza aggregazioni personalizzate, e join di al massimo due passaggi. Non c'è ricorsione. In Synalog, le regole si costruiscono su altre regole senza un catalogo imposto, i join arrivano fin dove la domanda richiede, e l'attraversamento dei grafi fa parte del linguaggio, con terminazione verificata.

dbt verifica che la configurazione semantica sia coerente e che l'SQL generato venga eseguito, e i test dbt possono controllare le tabelle: chiavi, valori nulli e riferimenti. Synalog dimostra che ogni regola è ben formata, sicura e termina prima di eseguirla, e le sue asserzioni, scritte in logica con una notazione diversa da quella delle regole, si applicano a qualsiasi regola, comprese quelle ricorsive e derivate: transitività, totali, periodi di validità.

Il server MCP di dbt offre agli agenti query sulle metriche governate, ma anche text-to-SQL e un'esecuzione SQL che non blocca le istruzioni di scrittura. L'analista di SynaLemma ha un solo percorso verso i vostri dati: il layer verificato, e basta un account in sola lettura. Le API del Semantic Layer richiedono inoltre un piano a pagamento della piattaforma dbt; SynaLemma gira sulla vostra infrastruttura con un piccolo modello aperto.

SynaLemma va oltre la consultazione delle metriche: ragiona sui vostri dati, con risposte che potete verificare.

Leggi il confronto completo

In sintesi. Ogni regola è verificata formalmente prima di essere eseguita, e i vostri dati sono controllati da asserzioni scritte in logica, con controesempi quando falliscono. Le domande sui grafi non richiedono un database a grafo: attraversamento, ricorsione e catene a più passaggi fanno parte del linguaggio, e compilano in SQL sui database che avete già. E poiché l'SQL è compilato dal motore, e non generato da un modello linguistico, basta un piccolo modello aperto, così l'intero sistema gira sulla vostra infrastruttura.

Tutti i confronti, compreso Looker →

Domande frequenti

Le prime domande che ci vengono poste.

Non abbiamo competenze di IA al nostro interno. È un problema?

No. SynaLemma è implementato da partner certificati: integratori e società di consulenza i cui ingegneri lavorano al fianco del vostro team per installarlo, collegare i vostri dati, e scrivere e verificare le vostre definizioni con i vostri esperti. Anche il vostro team può essere certificato.

Il modello non sta comunque ragionando quando scrive la regola?

Decide che cosa chiedere al motore: quali concetti combinare, e come. Questa decisione viene messa per iscritto come una regola che potete leggere, ed è il motore, e non il modello, a ricavarne ogni riga. Se la decisione è sbagliata, l'errore si trova in un punto che potete vedere, correggere una volta e bloccare.

SynaLemma è open source?

I tre motori su cui si basa (Synalinks, Synalog, Semantic Layers) sono open source con licenza Apache-2.0. SynaLemma, il prodotto che li assembla, è proprietario e venduto con licenza commerciale. Le vostre regole sono file nel formato aperto, quindi non restano mai vincolate al prodotto.

Con quali database funziona?

PostgreSQL, BigQuery, Databricks, Trino, Presto, DuckDB e SQLite, interrogati sul posto: le vostre tabelle restano dove sono. E con i file: CSV, Excel, JSON, JSONL e Parquet. Una stessa regola viene compilata nel dialetto SQL del motore su cui viene eseguita.

Con quali modelli linguistici?

Qualsiasi modello che supporti il tool calling, scelto da un catalogo nelle impostazioni: modelli aperti serviti in locale tramite Ollama, vLLM o LM Studio, oppure fornitori in hosting come Mistral, Anthropic, OpenAI o Google. Cambiare modello non cambia le regole. Tutto, tranne la conversazione stessa, funziona anche senza alcun modello.

E se il modello scrive una regola sbagliata?

Una regola strutturalmente errata viene rifiutata dal verificatore. Una regola che contraddice un'asserzione viene segnalata insieme alle righe che la violano. E poiché la regola è leggibile, la persona responsabile del numero può vederla e correggerla. Questo non è possibile quando la risposta è un paragrafo di testo.

Sostituisce le nostre dashboard?

No. SynaLemma non disegna grafici: le risposte sono numeri, tabelle e le regole che li producono. Dà alle definizioni alla base delle vostre dashboard un unico luogo in cui risiedere, e permette a persone e agenti di porre domande in linguaggio naturale basandosi su di esse.

Guardatelo all'opera

Portate una domanda su cui i vostri team non sono d'accordo.

In una demo gratuita di trenta minuti vi mostriamo la risposta di SynaLemma e la regola che ha usato.