Kumo SDK jobs can write several types of outputs outside the Kumo platform:
- batch prediction scores;
- entity embeddings generated during prediction;
- generated training tables;
- model artifacts for online serving bundles.
The export APIs use explicit configuration objects so production jobs can choose the destination connector, table name, write mode, and metadata columns.
Batch prediction outputs
Pass OutputConfig to trainer.predict() to write predictions and/or embeddings to a destination connector.
import kumoai as kumo
from kumoai.artifact_export.config import OutputConfig
output_config = OutputConfig(
output_types={"predictions", "embeddings"},
output_connector=connector,
output_table_name="kumo_predictions",
)
prediction_job = trainer.predict(
graph=graph,
prediction_table=pquery.generate_prediction_table(non_blocking=True),
training_job_id=training_job.job_id,
output_config=output_config,
non_blocking=False,
)
print(prediction_job.summary())
output_types controls which artifacts are written:
| Output type | Description |
|---|
predictions | Scored prediction results for the generated prediction table |
embeddings | Entity embeddings that can be used for downstream retrieval, analysis, or online serving preparation |
output_connector is omitted, Kumo produces a local-download output instead of writing to an external destination.
Destination connectors and table names
output_connector is any supported SDK connector that Kumo can write to for your deployment. output_table_name identifies the output location in that connector.
snowflake_output = OutputConfig(
output_types={"predictions"},
output_connector=snowflake_connector,
output_table_name="KUMO_PREDICTIONS",
)
bigquery_output = OutputConfig(
output_types={"predictions"},
output_connector=bigquery_connector,
output_table_name="kumo_predictions",
)
(schema, table) tuple for the destination table.
databricks_output = OutputConfig(
output_types={"predictions"},
output_connector=databricks_connector,
output_table_name=("analytics", "kumo_predictions"),
)
output_metadata_fields.
from kumoapi.jobs import MetadataField
output_config = OutputConfig(
output_types={"predictions"},
output_connector=snowflake_connector,
output_table_name="KUMO_PREDICTIONS",
output_metadata_fields=[
MetadataField.JOB_TIMESTAMP,
MetadataField.ANCHOR_TIMESTAMP,
],
)
JOB_TIMESTAMP records when the job was run. ANCHOR_TIMESTAMP records the prediction anchor time for temporal prediction tasks; requesting it for a non-temporal prediction task raises an error.
Append versus overwrite
Some connector types support connector-specific write modes. Use BigQueryOutputConfig or SnowflakeConnectorConfig with connector_specific_config.
from kumoapi.jobs import WriteMode
from kumoai.artifact_export.config import (
BigQueryOutputConfig,
OutputConfig,
SnowflakeConnectorConfig,
)
bigquery_output = OutputConfig(
output_types={"predictions"},
output_connector=bigquery_connector,
output_table_name="kumo_predictions",
connector_specific_config=BigQueryOutputConfig(
write_mode=WriteMode.APPEND,
),
)
snowflake_output = OutputConfig(
output_types={"predictions"},
output_connector=snowflake_connector,
output_table_name="KUMO_PREDICTIONS",
connector_specific_config=SnowflakeConnectorConfig(
write_mode=WriteMode.OVERWRITE,
),
)
MetadataField.JOB_TIMESTAMP so downstream consumers can distinguish runs.
Connector-specific configs are validated against the connector type. Passing a Snowflake config for a BigQuery connector, or passing connector-specific config to a connector type that does not support it, raises a ValueError.
Export generated training tables
Use TrainingTableExportConfig when you need to persist the full generated training table for inspection, governance, or downstream reuse.
from kumoai.artifact_export.config import TrainingTableExportConfig
training_table = pquery.generate_training_table(non_blocking=False)
export_config = TrainingTableExportConfig(
output_types={"training_table"},
output_connector=snowflake_connector,
output_table_name="KUMO_TRAINING_TABLE",
)
export_job = training_table.export(export_config, non_blocking=True)
export_job.attach()
TrainingTableExportConfig requires output_types={"training_table"}, an output_connector, and an output_table_name. Prediction metadata fields are not supported for training table exports. For BigQuery and Snowflake destinations, you can also use connector_specific_config to set the connector-specific write mode.
Export model artifacts for online serving
export_model() creates a model artifact export job. It bundles the online-serving model directory with embeddings from a batch prediction job and copies the bundle to the output path in ModelOutputConfig.
from kumoai.trainer import ModelOutputConfig, export_model
model_output = ModelOutputConfig(
training_job_id=training_job.job_id,
batch_prediction_job_id=prediction_job.job_id,
output_path="s3://my-bucket/kumo/serving-bundles/churn-model/",
)
export_job = export_model(model_output, non_blocking=True)
print(export_job.id)
print(export_job.status())
export_result = export_job.attach()
print(export_result.job_id)
non_blocking=False to wait for completion immediately.
export_result = export_model(model_output, non_blocking=False)
Monitoring export jobs
export_model(..., non_blocking=True) returns an ArtifactExportJob. Use the same future-style pattern as training and prediction jobs.
export_job = export_model(model_output, non_blocking=True)
print(export_job.status())
export_job.attach() # watch progress until complete
result = export_job.result()
# Cancel if the job no longer needs to run.
export_job.cancel()
result() raises an error.
Production tips
- Keep output table names deterministic so orchestration systems can find the latest run.
- Include run metadata columns when appending to shared prediction tables.
- Use separate output locations for predictions and embeddings if they have different downstream consumers.
- Export model artifacts only after the training and embedding-producing prediction jobs have completed successfully.
