Developer quickstart¶

brew install datarobot-oss/taps/dr-cli uv pulumi/tap/pulumi go-task node git python

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

import datarobot as dr

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

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='token-string')

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

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

# 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}"

# 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}"

# 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}"