# What Nexus is

<Term id="nexus">Nexus</Term> is your <Term id="workspace">workspace</Term>'s database. It holds **tables**, which you query with SQL, and **files**, which you keep in folders. Projects, agents, apps and the SDK all use the same Nexus, each with the access you gave it.

<TrustBadges />

## What Nexus holds [#what-nexus-holds]

| | What it is | Where you see it |
| --- | --- | --- |
| Tables | Rows and columns you filter, edit and query with SQL | **Data**, **Nexus Lakehouse** |
| Files | Any kind of file, kept in folders with every version | **Data**, **Object Storage** |
| Knowledge graph | The things in your tables and how they link | **Data**, **Knowledge graph** |

An uploaded spreadsheet is kept as a file, and you can turn it into a table in one step. A folder can import every new file into a table automatically.

## Tables are open Apache Iceberg tables [#tables-are-open-apache-iceberg-tables]

Nexus stores tables in the open <Term id="iceberg">Apache Iceberg</Term> format. That gives you:

- **History.** Every change is kept as a version. See who changed what, and go back when something goes wrong.
- **No lock-in.** Iceberg is an open standard that many tools read.
- **One way to work.** Small and large tables are queried, changed and restored the same way.

Compute and storage run on AWS.

## Schemas group tables [#schemas-group-tables]

A <Term id="schema">schema</Term> is a named group of tables, such as `sales` or `marketing`. Every workspace has a `default` schema that always exists. `sales.orders` is the table `orders` in `sales`; a name with no schema, such as `orders`, means the table in `default`.

Schemas keep areas of work apart and let you give access to a whole area at once (see [Data access](/docs/data/data-access)). A schema can only be deleted once it holds no tables and no files.

## The Nexus engine runs your queries [#the-nexus-engine-runs-your-queries]

Queries run on the <Term id="nexus-engine">Nexus engine</Term>, which speaks **Spark SQL**: `SELECT`, joins, `GROUP BY`, window functions and the rest work as you expect. Each query is checked first: it only reaches tables you have access to, and only reads as much data as your plan allows. You can ask what a query would read before you run it.

## Before you start [#before-you-start]

- **A workspace** you are a member of.
- **Access.** Owners and admins reach everything. Members reach everything unless an admin limits them. See [Data access](/docs/data/data-access).
- **Your plan's limits.** Storage, how much one query may read and how many rows come back depend on your plan. See them in <AppLink to="settings.usage" />, or in code with `nx.limits()`.

<Callout type="info" title="Plan limits">
Limits differ by plan. Always check your own in <AppLink to="settings.usage" /> rather than assuming.
</Callout>

## Find your way around [#find-your-way-around]

<ForEveryone>

Open <AppLink to="data" />. The Data area has these pages:

- **Add data**: upload files, turn a spreadsheet into a table, or browse connectors.
- **Nexus Lakehouse**: every table you can reach, by schema.
- **Object Storage**: your folders and files, with Trash and Activity.
- **Knowledge graph**: the things in your data and how they connect.
- **SQL editor**: write and run queries.
- **Storage used**: how much each schema stores, day by day.
- **Data management**: what changed in your data, and putting things back.

<Screenshot src="/docs/_media/nexus-tables-list.png" alt="The Data area with Nexus Lakehouse open" />

</ForEveryone>

<ForDevelopers>

<Callout type="info" title="Available on request">
The Klarety SDK and CLI are available on request. To request access for your workspace, [contact us](https://klarety.ai/contact).
</Callout>

Install the <Term id="sdk">SDK</Term> and connect with an <Term id="api-key">API key</Term> from <AppLink to="settings.sdk-api" />:

```bash
pip install klarety
```

```python title="nexus_tour.py"
from klarety import Nexus

nx = Nexus.connect("YOUR_API_KEY")

for schema in nx.schemas.list():
    print("schema", schema)

for table in nx.tables.list("default"):
    print("table", table)

result = nx.sql("SELECT 1 AS ok")
print(result.rows)

nx.close()
```

`Nexus.connect()` also reads the key from `KLARETY_API_KEY`. The `Nexus` object groups everything by area: `nx.tables`, `nx.schemas`, `nx.folders`, `nx.files`, `nx.knowledge_graph`, `nx.restores` and `nx.access`.

</ForDevelopers>

<Screenshot src="/docs/_media/nexus-data-usage.png" alt="Storage used, showing how much data the workspace keeps" />

<Screenshot src="/docs/_media/nexus-sidebar-compute-cpu-memory-usage-quick-overview.png" alt="The sidebar with a quick view of compute, CPU and memory use" />

## How your data stays safe [#how-your-data-stays-safe]

- **Every change is kept.** Tables keep their history and files keep every version. Deleted tables, folders and files can be restored for a while after.
- **Access is checked on every request.** People, projects and API keys reach only what they were given.
- **Secrets are encrypted** with a managed key service.
- **A read-back check.** Data management shows how long changes are kept, how long deleted items can be restored, and when the platform last checked that every file reads back.

## Where to go next [#where-to-go-next]

- [Add data](/docs/data/add-data): bring your first file or spreadsheet in.
- [Work with tables](/docs/data/tables): browse, edit, check and see history.
- [Query with SQL](/docs/data/sql-editor): run your first query.
- [Data access](/docs/data/data-access): choose who reaches what.