> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.nvidia.com/sdgm/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.nvidia.com/sdgm/_mcp/server.

# SQLite Connector

> Connect KumoRFM to data stored in SQLite

KumoRFM can connect directly to SQLite databases, automatically inferring table metadata and relationships from the database schema.

## Installation

The SQLite backend requires the ADBC SQLite driver:

```bash
pip install kumoai[sqlite]
```

Or install the driver directly:

```bash
pip install adbc_driver_sqlite
```

## Quick Start

The simplest way to create a graph from a SQLite database:

```python
import kumoai.rfm as rfm

graph = rfm.Graph.from_sqlite("my_database.db")
```

This will:

1. Connect to the SQLite database
2. Discover all tables automatically
3. Infer column metadata (data types, semantic types, primary keys, time columns)
4. Detect foreign key relationships from the database schema
5. Print a summary of the inferred metadata and links

## Specifying Tables

You can control which tables to include and customize their configuration:

```python
graph = rfm.Graph.from_sqlite("data.db", tables=[
    "USERS",                                      # Include by name
    dict(name="ORDERS", source_name="ORDERS_V2"), # Rename source table
    dict(name="ITEMS", primary_key="ITEM_ID"),    # Override primary key
])
```

Table configuration options:

| Key           | Description                                                      | Required |
| ------------- | ---------------------------------------------------------------- | -------- |
| `name`        | The table name used in PQL queries                               | Yes      |
| `source_name` | The actual table name in the database (if different from `name`) | No       |
| `primary_key` | Override the auto-detected primary key                           | No       |

## Connection Options

You can pass a file path or an existing ADBC connection:

```python
# From a file path (string or Path):
graph = rfm.Graph.from_sqlite("path/to/database.db")

# From an existing ADBC connection:
from kumoai.rfm.backend.sqlite import connect
conn = connect("path/to/database.db")
graph = rfm.Graph.from_sqlite(conn)
```

## Controlling Metadata Inference

By default, `Graph.from_sqlite()` infers metadata and links. You can disable this for manual configuration:

```python
graph = rfm.Graph.from_sqlite(
    "data.db",
    infer_metadata=False,  # Skip automatic type inference
    verbose=False,         # Suppress output
)

# Manually configure metadata afterwards:
graph.infer_metadata()
graph.infer_links()
```

## Manual Edge Specification

Override automatic link detection by providing edges explicitly:

```python
graph = rfm.Graph.from_sqlite("data.db", edges=[
    ("ORDERS", "user_id", "USERS"),
    ("ORDERS", "item_id", "ITEMS"),
])
```

## Optimizing Performance

When initializing `KumoRFM` with a SQLite-backed graph, the `optimize=True` flag creates database indices for faster context sampling:

```python
model = rfm.KumoRFM(graph, optimize=True)
```

This is recommended for larger databases where sampling performance matters. Note that this requires write access to the database file.