Gli altri sistemi ad agenti affidano il ragionamento al modello linguistico. SynaLemma è un harness 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.
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.
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.
Il modello traduce la vostra domanda in una regola e formula la risposta. Ogni inferenza nel mezzo è del motore, e può essere rieseguita.
Ogni livello 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.
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.
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.
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.
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.
Il vostro modello · locale o in hosting, sostituibile
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.
Se nessuna è adatta, ne scrive una, partendo dai concetti già presenti invece che dalle tabelle grezze.
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.
La regola verificata viene compilata in SQL ed eseguita nel vostro database. Le sue asserzioni vengono controllate sugli stessi dati.
Solo allora l'assistente risponde, riportando le righe restituite dall'esecuzione e citando la regola, che potete aprire.
La regola viene salvata nel layer con un commit, con autore e data. La domanda successiva parte da lì.
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.
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.
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.
✗ 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 |
+-------------------+------+----+-------+
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.
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.
Un layer semantico è 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.
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.
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.
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.
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.
Entità e relazioni vengono modellate sulle vostre tabelle relazionali. Il grafo è virtuale: viene compilato 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.
E i vostri file: CSV, Excel, JSON, JSONL, Parquet.
Il layer vi appartiene. Tutto ciò che l'assistente scrive può essere letto, corretto e bloccato da una persona.
SynaLemma viene installato sulla vostra infrastruttura. Con un modello locale, nulla ne esce. Con un modello in hosting, le vostre domande e gli estratti di dati necessari per rispondere vanno al fornitore che avete scelto, e a nessun altro.
Modelli aperti sul vostro hardware (Ollama, vLLM, LM Studio) oppure il fornitore con cui avete già un contratto. Le regole non dipendono dal modello.
Interrogati sul posto, tramite un account che ha bisogno solo di leggere. Le credenziali dei database sono conservate in forma cifrata. I messaggi vocali registrati nell'app vengono trascritti sul vostro server.
Semplici file in un linguaggio aperto, su motori pubblicati con licenza Apache-2.0. Funzionano anche con i soli strumenti open source.
No. SynaLemma include uno o più ingegneri forward-deployed dedicati, a seconda delle dimensioni del vostro progetto, provenienti dal team che lo sviluppa. Lavorano al fianco del vostro team per installarlo, gestire i vostri dati e scrivere e verificare le vostre definizioni insieme ai vostri esperti.
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.
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.
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.
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.
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.
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.
In una demo gratuita di trenta minuti vi mostriamo la risposta di SynaLemma e la regola che ha usato.
