A fast, AI-native database engine that also makes migrations and translation between systems provable and repeatable.

SAIQL in one sentence:

SAIQL is a database engine designed for LLM era workloads, with QIPI indexing and LoreCore storage. It can act as a universal middle layer that moves and translates data across older databases with audit-grade proof, and now includes Atlas, a semantic RAG engine that uses LoreTokens to give LLMs compressed, structured, auditable memory.

The short version, without the nap

SAIQL was built for a world where software is no longer just written for humans. It is built for humans and AI agents working together, where speed, determinism, and trust matter as much as features.

• First, it is its own database engine, built for AI and ML workloads.
• Second, it is a universal migration hub: Any DB to SAIQL IR to Any DB, with proof bundles.
• Third, it can operate as a translator layer between an LLM and older databases, so the model speaks safely and the database stays sane.
• Fourth, it includes Atlas, a semantic RAG engine that uses LoreTokens to give LLMs structured, citation-backed memory with safety and governance built in.

1) SAIQL as an AI native database engine

At its core, SAIQL is not just a connector toolkit. It is a database engine built around modern AI realities: fast lookups, native vector search, semantic queries, and storage layouts that do not assume a 1990s world.

QIPI, the speed trick that is not a trick

SAIQL uses QIPI, a multi layer indexing approach designed to make point lookups and hot reads extremely fast. The goal is simple: when an agent asks, it should get the answer quickly, and when it asks the same thing again, it should be even faster.

LoreCore, the storage layer that keeps it flexible

SAIQL is powered by LoreCore, a storage abstraction that lets SAIQL run embedded for local use or external for production deployments. That means the same engine can power a laptop demo and a server deployment without rewriting the world.

• Embedded mode supports local workflows and edge use cases.
• External mode supports production deployments and higher concurrency.
• The storage backend is a choice, not a rewrite.

Why it was built for LLMs specifically

LLMs are great at reasoning and language. They are not great at being a database. SAIQL is designed to be the long term memory and query layer that an agent can rely on, without forcing the agent to hallucinate structure.

• Agent friendly query surface, so tools and models can stay consistent.
• Built in patterns for retrieval workflows, including semantic and vector search.
• Performance tuned for lots of small queries, not just big report jobs.

2) SAIQL as a universal database migration hub

SAIQL also solves the painful problem that traps most teams: moving from one database to another without breaking reality. Instead of one off conversions from System A to System B, SAIQL converts into a neutral intermediate representation, then writes out to the target.

• Any DB to SAIQL IR to Any DB for schema and data migrations.
• Deterministic run bundles, so you can rerun the same job and get the same story.
• Audit grade artifacts, so you can prove what moved, what changed, and what was skipped.

What audit grade actually means here

It means you get evidence you can hand to someone skeptical. Logs, manifests, parity summaries, validation reports, and explicit limitations. If something cannot be migrated safely, it is reported as a limitation instead of being silently guessed.

3) SAIQL as a translator between LLMs and older databases

A lot of databases are not going away. They are stable, mission critical, and full of legacy rules. SAIQL can sit between an LLM and those systems to translate intent into safe, dialect correct queries, and to convert results back into an agent friendly format.

• LLM asks in plain language, SAIQL produces safe SQL for the right dialect.
• SAIQL can enforce rules, subset boundaries, and safety defaults.
• The database stays protected from accidental chaos.

4) SAIQL Atlas: Semantic RAG with LoreTokens

Atlas is SAIQL's semantic retrieval engine, designed to give LLMs reliable, auditable memory. Unlike typical RAG systems that chunk raw text and hope embeddings capture meaning, Atlas uses LoreTokens -- a semantic compression format designed specifically for LLM consumption.

LoreTokens: Why Atlas retrieval is different at the data level

Most RAG systems treat documents as bags of text. They chunk arbitrarily, embed the chunks, and retrieve by vector similarity. The chunks have no structure -- just raw strings.

Atlas stores knowledge as LoreTokens: a semantic encoding format that preserves meaning and structure in a way LLMs naturally understand. Instead of retrieving "a paragraph that might be relevant," Atlas retrieves structured semantic units with explicit keys, values, and relationships.

• Context efficient: LoreTokens compress information into dense, meaningful representations. An LLM gets more signal per token of context.
• Semantically structured: Data is not just text -- it carries explicit metadata, relationships, and type information that survives the retrieval process.
• LLM native: The format is designed for how language models process information, not how humans read documents.

What Atlas does differently

Most retrieval systems are probabilistic: you get results that are probably relevant, and you hope for the best. Atlas is deterministic: same query, same index, same results. Every time. With proof.

• Semantic hybrid retrieval: Atlas combines metadata filtering, keyword search, and semantic search in a single pipeline. LoreTokens enable filtering on structured fields, not just vector similarity.
• Citations by default: Every retrieved LoreToken includes its source, version, and exact location. No more "the AI said so" without evidence.
• Safety as a first class feature: Atlas detects prompt injection patterns in documents and can downrank or block flagged content before it reaches the model.
• Proof bundles: Every retrieval run produces a manifest with configuration, timing, and audit trails. You can prove what was retrieved and why.

Why Atlas exists

LLMs need memory, but memory without governance is a liability. Atlas is built for environments where you need to:

• Know exactly what context the model saw
• Prove that results are reproducible
• Protect against malicious content in documents
• Audit retrieval decisions after the fact

Why SAIQL was created

SAIQL began inside a separate private project two years ago where data quality, speed, and repeatability were non negotiable, and existing databases couldn't meet the demands. That mindset carried over: build the engine for the AI era first, then make it speak to everything else. Realizing its potential, it has seen tremendous enhancements over the past few months.

Recent improvements that matter in the real world

Recent work has focused on credibility and operational trust. The theme is proof first: do not claim support unless it passes harness tests and produces usable evidence.

• Capability levels that make support honest and measurable, instead of vague promises.
• Stronger run artifacts so every conversion produces a reviewable evidence bundle.
• Regression gating, so proven behavior does not quietly break later.
• A clean separation between the core engine and the migration lanes, so each can evolve without breaking the other.
• Atlas retrieval engine for governed LLM memory (in development, gated release).

Current supported databases

Database	Capability Levels
PostgreSQL	L0, L1, L2, L3, L4
MySQL	L0, L1, L2, L3, L4
MariaDB	L0, L1, L2, L3, L4
SQLite	L0, L2, L3, L4
SAP HANA	L2, L3, L4
SQL Server	L0, L2, L3, L4
Oracle	L0, L1, L2, L3, L4
File (CSV/Excel)	L2, L3, L4

Capability Levels: L0: Tables, columns, types, data extraction | L1: Keys, constraints, indexes | L2: Views | L3: Procedures, functions | L4: Triggers, packages, advanced

Planned targets

• Tier 2: IBM Db2, Teradata
• Tier 3 (warehouse/cloud): BigQuery, Snowflake, Redshift
• Tier 4 (if IR extended): MongoDB, Redis, document models

Already implicitly supported

CockroachDB, YugabyteDB, AlloyDB, Aurora, Cloud SQL (via PostgreSQL adapter). TiDB, PlanetScale, SingleStore (via MySQL adapter). Azure SQL Database (via SQL Server adapter).

FAQs

How is Atlas different from LangChain or LlamaIndex?

Atlas is a semantic RAG engine, not a framework. It uses LoreTokens for structured retrieval, enforces citations by default, and produces audit-grade proof bundles. It competes on governance and determinism, not ecosystem size.

Does Atlas require an external vector database?

No. Atlas uses QIPI, SAIQL's built-in indexing layer. No Pinecone, Weaviate, or ChromaDB required -- though external options can be used if preferred.

What are LoreTokens?

LoreTokens are SAIQL's proprietary semantic compression format. Instead of storing raw text chunks, LoreTokens preserve structure, metadata, and relationships in a format optimized for LLM consumption. LoreTokens are the foundation of all our developments, and provide a very serious advantage -- structured semantics at microsecond speeds, an advantage that cannot be replicated by bolting vector search onto raw text.

Is SAIQL deterministic?

Yes. Same inputs, same config, same outputs. Every run produces proof bundles so you can verify reproducibility.

How fast is SAIQL?

QIPI, SAIQL's index engine, achieves point lookups in ~6 microseconds and range searches in ~500 microseconds on commodity hardware -- roughly 1000x faster than SQLite for point lookups. The trade-off is slower writes for instant reads. For retrieval workloads where read speed matters, this is exactly the right trade-off.

Is a SAIQL Cloud Service planned?

Update: SAIQL Cloud has been announced.

---

The bottom line: SAIQL is not trying to be everything to everyone. It is built for teams that need a database engine that understands AI workloads, migrations that produce evidence instead of hope, a safe bridge between LLMs and legacy systems, and semantic retrieval that is structured, auditable, and safe -- not just "similar vectors."

The difference is in the data layer. Most tools treat knowledge as text to embed. SAIQL treats knowledge as structured semantic units (LoreTokens) that LLMs can reason over, not just pattern-match against.