API quickstart¶

endpoint: 'https://app.datarobot.com/api/v2'
token: 'NjE3ZjA3Mzk0MmY0MDFmZGFiYjQ0MztergsgsQwOk9G'

import datarobot as dr

import datarobot as dr
dr.Client(config_path = "<file-path-to-drconfig.yaml>")

ConnectToDataRobot(configPath = "<file-path-to-drconfig.yaml>"))

# Extract values from drconfig.yaml and set as environment variables
export DATAROBOT_ENDPOINT=$(grep 'endpoint:' ~/.config/datarobot/drconfig.yaml | cut -d "'" -f2)
export DATAROBOT_API_TOKEN=$(grep 'token:' ~/.config/datarobot/drconfig.yaml | cut -d "'" -f2)

curl --location -X GET "${DATAROBOT_ENDPOINT}/projects" --header "Authorization: Bearer ${DATAROBOT_API_TOKEN}"

setx DATAROBOT_ENDPOINT "https://app.datarobot.com/api/v2"
setx DATAROBOT_API_TOKEN "your_api_token"

export DATAROBOT_ENDPOINT="https://app.datarobot.com/api/v2"
export DATAROBOT_API_TOKEN="your_api_token"

import datarobot as dr
dr.Project.list()

curl --location -X GET "${DATAROBOT_ENDPOINT}/projects" --header "Authorization: Bearer ${DATAROBOT_API_TOKEN}"

import datarobot as dr
dr.Client(endpoint='https://app.datarobot.com/api/v2', token='NjE3ZjA3Mzk0MmY0MDFmZGFiYjQ0MztergsgsQwOk9G')

curl --location --request GET 'https://app.datarobot.com/api/v2/projects/' \
--header 'Authorization: Bearer <YOUR_API_TOKEN>'

ConnectToDataRobot(endpoint =
"https://app.datarobot.com/api/v2",
token =
'NjE3ZjA3Mzk0MmY0MDFmZGFiYjQ0MztergsgsQwOk9G')

import datarobot as dr
dr.Client(config_path = "./drconfig.yaml")

# Set to the location of your auto-mpg.csv and auto-mpg-test.csv data files
# Example: dataset_file_path = '/Users/myuser/Downloads/auto-mpg.csv'
training_dataset_file_path = './auto-mpg.csv'
test_dataset_file_path = './auto-mpg-test.csv'
print("--- Starting DataRobot Model Training Script ---")

# Load dataset
training_dataset = dr.Dataset.create_from_file(training_dataset_file_path)

# Create a new project based on dataset
project = dr.Project.create_from_dataset(training_dataset.id, project_name='Auto MPG DR-Client')

DATAROBOT_API_TOKEN=${DATAROBOT_API_TOKEN}
DATAROBOT_ENDPOINT=${DATAROBOT_ENDPOINT}
DATASET_FILE_PATH="./auto-mpg.csv"
location=$(curl -Lsi \
  -X POST \
  -H "Authorization: Bearer ${DATAROBOT_API_TOKEN}" \
  -F 'projectName="Auto MPG"' \
  -F "file=@${DATASET_FILE_PATH}" \
  "${DATAROBOT_ENDPOINT}"/projects/ | grep -i 'Location: .*$' | \
  cut -d " " -f2 | tr -d '\r')
echo "Uploaded dataset. Checking status of project at: ${location}"
while true; do
  project_id=$(curl -Ls \
    -X GET \
    -H "Authorization: Bearer ${DATAROBOT_API_TOKEN}" "${location}" \
    | grep -Eo 'id":\s"\w+' | cut -d '"' -f3 | tr -d '\r')
  if [ "${project_id}" = "" ]
  then
    echo "Setting up project..."
    sleep 10
  else
    echo "Project setup complete."
    echo "Project ID: ${project_id}"
    break
  fi
done

# Set to the location of your auto-mpg.csv and auto-mpg-test.csv data files
# Example: dataset_file_path = '/Users/myuser/Downloads/auto-mpg.csv'
training_dataset_file_path <- "./auto-mpg.csv"
test_dataset_file_path <- "./auto-mpg-test.csv"

# Load dataset using modern DataRobot R client
training_dataset <- UploadDataset(training_dataset_file_path)
test_dataset <- utils::read.csv(test_dataset_file_path)

# Create a new project based on dataset
project <- CreateProject(training_dataset, projectName = "Auto MPG DR-Client")

# Use training data to build models
from datarobot import AUTOPILOT_MODE

# Set the project's target and initiate Autopilot (runs in Quick mode unless a different mode is specified)
project.analyze_and_model(target='mpg', worker_count=-1, mode=AUTOPILOT_MODE.QUICK)
print("\nAutopilot is running. This may take some time...")
project.wait_for_autopilot()
print("Autopilot has completed!")

# Open the project in a web browser to view progress
print("Opening the project in your default web browser to view real-time events...")
project.open_in_browser()

# Get the recommended model (the best model for deployment)
print("\nRetrieving the best model from the Leaderboard...")
best_model = project.recommended_model()
print(f"Best Model Found:")
print(f"  - Model Type: {best_model.model_type}")
print(f"  - Blueprint ID: {best_model.blueprint_id}")

response=$(curl -Lsi \
  -X PATCH \
  -H "Authorization: Bearer ${DATAROBOT_API_TOKEN}" \
  -H "Content-Type: application/json" \
  --data '{"target": "mpg", "mode": "quick"}' \
  "${DATAROBOT_ENDPOINT}/projects/${project_id}/aim" | grep 'location: .*$' \
  | cut -d " " | tr -d '\r')
echo "AI training initiated. Checking status of training at: ${response}"
while true; do
  initial_project_status=$(curl -Ls \
  -X GET \
  -H "Authorization: Bearer ${DATAROBOT_API_TOKEN}" "${response}" \
  | grep -Eo 'stage":\s"\w+' | cut -d '"' -f3 | tr -d '\r')
  if [ "${initial_project_status}" = "" ]
  then
    echo "Setting up AI training..."
    sleep 10
  else
    echo "Training AI."
    echo "Grab a coffee or catch up on email."
    break
  fi
done

echo "Polling for Autopilot completion..."
while true; do
  autopilot_done=$(curl -s \
    -X GET \
    -H "Authorization: Bearer ${DATAROBOT_API_TOKEN}" \
    "${DATAROBOT_ENDPOINT}/projects/${project_id}/" \
    | grep -Eo '"autopilotDone":\s*(true|false)' | cut -d ':' -f2 | tr -d ' ')

  if [ "${autopilot_done}" = "true" ]; then
    echo "Autopilot training complete. Model ready to deploy."
    break
  else
    echo "Autopilot training in progress... checking again in 60 seconds."
    sleep 60
  fi
done

# Get the recommended model ID
recommended_model_id=$(curl -s \
  -X GET \
  -H "Authorization: Bearer ${DATAROBOT_API_TOKEN}" \
  "${DATAROBOT_ENDPOINT}/projects/${project_id}/recommendedModels/recommendedModel/" \
  | grep -Eo 'modelId":\s"\w+' | cut -d '"' -f3 | tr -d '\r')
echo "Recommended model ID: ${recommended_model_id}"

# Set the project target and initiate Autopilot in Quick mode
SetTarget(project, target = "mpg")

# Start Autopilot in Quick mode (equivalent to Python's AUTOPILOT_MODE.QUICK)
StartAutopilot(project, mode = "quick")

# Block execution until Autopilot is complete
WaitForAutopilot(project)

# Open the project in a web browser to view progress
OpenProject(project)

# Get the recommended model (the best model for deployment)
model <- GetRecommendedModel(project, type = RecommendedModelType$RecommendedForDeployment)

# Deploy the model to a serverless prediction environment
print("\nDeploying the model to a serverless prediction environment...")

# Find or create a serverless prediction environment
serverless_env = None
for env in dr.PredictionEnvironment.list():
    if env.platform == 'datarobotServerless':
        serverless_env = env
        break

if serverless_env is None:
    print("Creating a new serverless prediction environment...")
    serverless_env = dr.PredictionEnvironment.create(
        name="Auto MPG Serverless Environment",
        platform='datarobotServerless'
    )

# First, register the model to create a registered model version
print("Registering the model...")

# Check if the registered model already exists
registered_model_name = "Auto MPG Registered Model"
existing_models = [m for m in dr.RegisteredModel.list() if m.name == registered_model_name]

if existing_models:
    print(f"Using existing registered model: {registered_model_name}")
    registered_model = existing_models[0]
    # Create a new version of the existing model
    registered_model_version = dr.RegisteredModelVersion.create_for_leaderboard_item(
        best_model.id,
        name="Auto MPG Model",
        registered_model_id=registered_model.id
    )
else:
    print(f"Creating new registered model: {registered_model_name}")
    # Create a new registered model
    registered_model_version = dr.RegisteredModelVersion.create_for_leaderboard_item(
        best_model.id,
        name="Auto MPG Model",
        registered_model_name=registered_model_name
    )
    # Retrieve the newly created registered model object by ID
    registered_model = dr.RegisteredModel.get(registered_model_version.registered_model_id)

# Wait for the model build to complete
print("Waiting for model build to complete...")
while True:
    current_version = registered_model.get_version(registered_model_version.id)
    if current_version.build_status in ('READY', 'complete'):
        print("Model build completed successfully!")
        registered_model_version = current_version  # Update our reference
        break
    elif current_version.build_status == 'FAILED':
        raise Exception("Model build failed. Please check the model registration.")
    else:
        print(f"Build status: {current_version.build_status}. Waiting...")
        import time
        time.sleep(30)  # Wait 30 seconds before checking again

# Deploy the model to the serverless environment using the registered model version
deployment = dr.Deployment.create_from_registered_model_version(
    registered_model_version.id,
    label="Auto MPG Predictions",
    description="Deployed with DataRobot client for Auto MPG predictions",
    prediction_environment_id=serverless_env.id
)

print(f"Model deployed successfully! Deployment ID: {deployment.id}")

# Use the recommended model ID from training section
echo "Using recommended model ID: ${recommended_model_id}"

# Find or create a serverless prediction environment
echo "Looking for serverless prediction environment..."
serverless_env_id=$(curl -s -X GET \
-H "Authorization: Bearer ${DATAROBOT_API_TOKEN}" \
"${DATAROBOT_ENDPOINT}/predictionEnvironments/" \
| grep -Eo '"id":"[^"]*".*"platform":"datarobotServerless"' \
| grep -Eo '"id":"[^"]*"' | cut -d '"' -f4 | head -1)

if [ -z "${serverless_env_id}" ]; then
    echo "Creating new serverless prediction environment..."
    serverless_env_response=$(curl -s -X POST \
    -H "Authorization: Bearer ${DATAROBOT_API_TOKEN}" \
    -H "Content-Type: application/json" \
    --data '{"name":"Auto MPG Serverless Environment","platform":"datarobotServerless"}' \
    "${DATAROBOT_ENDPOINT}/predictionEnvironments/")
    serverless_env_id=$(echo "$serverless_env_response" | grep -Eo '"id":"[^"]*"' | cut -d '"' -f4)
    echo "Created serverless environment ID: ${serverless_env_id}"
else
    echo "Using existing serverless environment ID: ${serverless_env_id}"
fi

# Check if registered model already exists
registered_model_name="Auto MPG Registered Model"
existing_model_id=$(curl -s -X GET \
-H "Authorization: Bearer ${DATAROBOT_API_TOKEN}" \
"${DATAROBOT_ENDPOINT}/registeredModels/" \
| grep -Eo '"id":"[^"]*".*"'${registered_model_name}'"' \
| grep -Eo '"id":"[^"]*"' | cut -d '"' -f4 | head -1)

if [ -n "${existing_model_id}" ]; then
    echo "Using existing registered model: ${registered_model_name}"
    # Create new version of existing model
    model_version_response=$(curl -s -X POST \
    -H "Authorization: Bearer ${DATAROBOT_API_TOKEN}" \
    -H "Content-Type: application/json" \
    --data "{\"name\":\"Auto MPG Model\",\"registeredModelId\":\"${existing_model_id}\",\"leaderboardItemId\":\"${recommended_model_id}\"}" \
    "${DATAROBOT_ENDPOINT}/registeredModels/${existing_model_id}/versions/")
else
    echo "Creating new registered model: ${registered_model_name}"
    # Create new registered model
    model_response=$(curl -s -X POST \
    -H "Authorization: Bearer ${DATAROBOT_API_TOKEN}" \
    -H "Content-Type: application/json" \
    --data "{\"name\":\"${registered_model_name}\"}" \
    "${DATAROBOT_ENDPOINT}/registeredModels/")
    existing_model_id=$(echo "$model_response" | grep -Eo '"id":"[^"]*"' | cut -d '"' -f4)

    # Create first version
    model_version_response=$(curl -s -X POST \
    -H "Authorization: Bearer ${DATAROBOT_API_TOKEN}" \
    -H "Content-Type: application/json" \
    --data "{\"name\":\"Auto MPG Model\",\"registeredModelId\":\"${existing_model_id}\",\"leaderboardItemId\":\"${recommended_model_id}\"}" \
    "${DATAROBOT_ENDPOINT}/registeredModels/${existing_model_id}/versions/")
fi

model_version_id=$(echo "$model_version_response" | grep -Eo '"id":"[^"]*"' | cut -d '"' -f4)
echo "Model version ID: ${model_version_id}"

# Wait for model build to complete
echo "Waiting for model build to complete..."
while true; do
    build_status=$(curl -s -X GET \
    -H "Authorization: Bearer ${DATAROBOT_API_TOKEN}" \
    "${DATAROBOT_ENDPOINT}/registeredModels/${existing_model_id}/versions/${model_version_id}/" \
    | grep -Eo '"buildStatus":"[^"]*"' | cut -d '"' -f4)

    if [ "${build_status}" = "READY" ] || [ "${build_status}" = "complete" ]; then
        echo "Model build completed successfully!"
        break
    elif [ "${build_status}" = "FAILED" ]; then
        echo "Model build failed. Please check the model registration."
        exit 1
    else
        echo "Build status: ${build_status}. Waiting..."
        sleep 30
    fi
done

# Deploy the model using the registered model version
echo "Deploying the model to the serverless environment..."
deployment_response=$(curl -s -X POST \
-H "Authorization: Bearer ${DATAROBOT_API_TOKEN}" \
-H "Content-Type: application/json" \
--data "{\"label\":\"Auto MPG Predictions\",\"description\":\"Deployed with cURL for Auto MPG predictions\",\"predictionEnvironmentId\":\"${serverless_env_id}\",\"registeredModelVersionId\":\"${model_version_id}\"}" \
"${DATAROBOT_ENDPOINT}/deployments/fromRegisteredModelVersion/")

deployment_id=$(echo "$deployment_response" | grep -Eo '"id":"[^"]*"' | cut -d '"' -f4)
echo "Model deployed successfully! Deployment ID: ${deployment_id}"

# Get the prediction URL for the deployment
echo "Retrieving prediction URL for deployment..."
prediction_url=$(curl -s -X GET \
  -H "Authorization: Bearer ${DATAROBOT_API_TOKEN}" \
  "${DATAROBOT_ENDPOINT}/deployments/${deployment_id}/" \
  | grep -Eo '"predictionUrl":"[^"]*"' | cut -d '"' -f4)
echo "Prediction URL: ${prediction_url}"

# Deploy the model to a serverless prediction environment
cat("Deploying the model to a serverless prediction environment...\n")

# Find or create a serverless prediction environment
prediction_environments <- ListPredictionEnvironments()
serverless_env <- NULL
for (env in prediction_environments) {
  if (env$platform == "datarobotServerless") {
    serverless_env <- env
    break
  }
}

if (is.null(serverless_env)) {
  cat("Creating a new serverless prediction environment...\n")
  serverless_env <- CreatePredictionEnvironment(
    name = "Auto MPG Serverless Environment",
    platform = "datarobotServerless"
  )
}

# Register the model to create a registered model version
cat("Registering the model...\n")
registered_model_name <- "Auto MPG Registered Model"

# Check if registered model already exists
existing_models <- ListRegisteredModels()
existing_model <- NULL
for (m in existing_models) {
  if (m$name == registered_model_name) {
    existing_model <- m
    break
  }
}

if (!is.null(existing_model)) {
  cat("Using existing registered model:", registered_model_name, "\n")
  # Create a new version of the existing model
  registered_model_version <- CreateRegisteredModelVersion(
    model_id = model$modelId,
    name = "Auto MPG Model",
    registered_model_id = existing_model$id
  )
} else {
  cat("Creating new registered model:", registered_model_name, "\n")
  # Create a new registered model
  registered_model <- CreateRegisteredModel(name = registered_model_name)
  # Create first version
  registered_model_version <- CreateRegisteredModelVersion(
    model_id = model$modelId,
    name = "Auto MPG Model",
    registered_model_id = registered_model$id
  )
}

# Wait for the model build to complete
cat("Waiting for model build to complete...\n")
while (TRUE) {
  current_version <- GetRegisteredModelVersion(registered_model_version$id)
  if (current_version$buildStatus %in% c("READY", "complete")) {
    cat("Model build completed successfully!\n")
    break
  } else if (current_version$buildStatus == "FAILED") {
    stop("Model build failed. Please check the model registration.")
  } else {
    cat("Build status:", current_version$buildStatus, ". Waiting...\n")
    Sys.sleep(30)  # Wait 30 seconds before checking again
  }
}

# Deploy the model to the serverless environment using the registered model version
deployment <- CreateDeploymentFromRegisteredModelVersion(
  registered_model_version_id = registered_model_version$id,
  label = "Auto MPG Predictions",
  description = "Deployed with DataRobot R client for Auto MPG predictions",
  prediction_environment_id = serverless_env$id
)

cat("Model deployed successfully! Deployment ID:", deployment$id, "\n")

# Make predictions on test data
print("\nMaking predictions on test data...")

# Read the test data directly
import pandas as pd
from datarobot_predict.deployment import predict

test_data = pd.read_csv(test_dataset_file_path)

# Use datarobot-predict for deployment predictions
predictions, response_headers = predict(deployment, test_data)

# Display the results
print("\nPrediction Results:")
print(predictions.head())
print(f"\nTotal predictions made: {len(predictions)}")

# Use the prediction URL from deployment section
TEST_DATASET_FILE_PATH="./auto-mpg-test.csv"

# Make predictions by sending the CSV data directly
predictions=$(curl -s -X POST \
  -H "Authorization: Bearer ${DATAROBOT_API_TOKEN}" \
  -H "Content-Type: text/csv; charset=UTF-8" \
  --data-binary "@${TEST_DATASET_FILE_PATH}" \
  "${prediction_url}")

echo "Prediction Results:"
echo "$predictions" | jq '.'

prediction_count=$(echo "$predictions" | jq '.data | length')
echo "Total predictions made: ${prediction_count}"

# Make predictions on test data
cat("Making predictions on test data...\n")

# Read the test data directly
test_data <- read.csv(test_dataset_file_path)

# Use the deployment for predictions (modern approach)
predictions <- PredictDeployment(deployment, test_data)

# Display the results
cat("Prediction Results:\n")
print(head(predictions))
cat("Total predictions made:", nrow(predictions), "\n")