> 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.

# Configure Table Metadata

> Review and correct Kumo Relational's inferred keys, timestamps, and semantic types

After you create a graph, review the inferred metadata for every table so Kumo Relational can identify entities, interpret column values, and use the correct event times when building prediction context.
Access a table through `graph["table_name"]`; you do not need to construct table objects directly.

## Inspect inferred metadata

Continue with the graph created in [Create a graph](/kumo-relational/user-guide/build-a-relational-graph/graph-creation):

```python
graph.print_metadata()
```

The output shows each table's inferred primary key, time columns, and column types.
Access the tables that you need to correct:

```python
customers_table = graph["customers"]
orders_table = graph["orders"]
products_table = graph["products"]
```

## Configure keys and timestamps

A primary key uniquely identifies each row in a table.
A time column identifies when a row became available to the prediction workflow.
Set these fields when inference did not select the intended columns:

```python
customers_table.primary_key = "customer_id"
orders_table.primary_key = "order_id"
orders_table.time_column = "order_time"
products_table.primary_key = "product_id"
```

Use an end-time column only when a record stops being valid at a known time.
The time column should represent when an event became available to the prediction workflow.

Tables can use composite primary keys when one column is not sufficient to identify a row.
Configure the complete ordered set of key columns, and ensure every corresponding composite foreign key uses compatible physical and semantic types in the same order.

```python
customers_table.primary_key = ("customer_id", "region")
```

Every component must be present, non-null, and use a physical type that the SDK can combine into a composite identifier, also called a foldable type.
Floating-point columns cannot be components of a composite identity.
When you request predictions for entities with a composite key, pass one tuple per entity in the same order:

```python
result = client.relational(graph).predict(
    query,
    indices=[("AB-10015", "Central"), ("ZZ-00001", "West")],
)
```

Refer to [Time and End-Time Columns](/kumo-relational/user-guide/prepare-data/time-columns) for selection guidance, entity-table validity rules, and current sampling behavior for related tables.

## Correct semantic types

A semantic type tells Kumo Relational how to interpret a column's values, regardless of how those values are physically stored.
Correct an inferred semantic type when it does not match the column's role:

```python
from kumo_relational_client import relational

customers_table["customer_id"].stype = relational.Stype.ID
orders_table["order_id"].stype = relational.Stype.ID
orders_table["customer_id"].stype = relational.Stype.ID
orders_table["product_id"].stype = relational.Stype.ID
orders_table["order_time"].stype = relational.Stype.timestamp
products_table["product_id"].stype = relational.Stype.ID
```

A semantic type assignment must be compatible with the column's physical data type.
Refer to [Data Types and Semantic Types](/kumo-relational/user-guide/prepare-data/data-types) for the supported combinations.

## Metadata checklist

* Each table's primary key values are non-null and unique.
* Foreign-key columns use values and physical data types that are compatible with those of the referenced keys.
* The time column represents when an event became available to the prediction workflow.
* Identifier columns use the `ID` semantic type.
* Free-form language uses the `text` semantic type, and low-cardinality labels use the `categorical` semantic type.
* End-time columns are used only when records stop being valid at a known time.

Inspect the result after making corrections:

```python
graph.print_metadata()
```

Next, [review and define relationships](/kumo-relational/user-guide/build-a-relational-graph/graph-definitions).