Datasets SDK Reference

Datasets

List Datasets

Retrieves a paginated list of datasets for the current workspace.

from orq_ai_sdk import Orq
import os

with Orq(
    api_key=os.getenv("ORQ_API_KEY", ""),
) as orq:

    res = orq.datasets.list(limit=10)

    # Handle response
    print(res)

import { Orq } from "@orq-ai/node";

const orq = new Orq({
  apiKey: process.env["ORQ_API_KEY"] ?? "",
});

async function run() {
  const result = await orq.datasets.list({
    limit: 10,
  });

  console.log(result);
}

run();

Show Parameters

{
    "limit": Optional[int],
    "starting_after": Optional[str],
    "ending_before": Optional[str],
    "search": Optional[str],
    "updated_by": Optional[str],
    "project_id": Optional[str],
}

{
  limit?: number;
  startingAfter?: string;
  endingBefore?: string;
  search?: string;
  updatedBy?: string;
  projectId?: string;
}

Show Response

{
    "object": str,
    "data": [{
        "display_name": str,
        "project_id": str,
        "metadata": {
            "total_versions": int,
            "datapoints_count": int,
        },
        "created_by_id": str,
        "updated_by_id": str,
        "created": str,
        "updated": str,
        "workspace_id": str,
        "id": str,
    }],
    "has_more": bool,
}

{
  object: string;
  data: {
    displayName: string;
    projectId: string;
    metadata: {
      totalVersions: number;
      datapointsCount: number;
    };
    createdById: string;
    updatedById: string;
    created: string;
    updated: string;
    workspaceId: string;
    id: string;
  }[];
  hasMore: boolean;
}

Create a Dataset

Creates a new dataset in the project bound to the API key, or in the workspace default project.

from orq_ai_sdk import Orq
import os

with Orq(
    api_key=os.getenv("ORQ_API_KEY", ""),
) as orq:

    res = orq.datasets.create(display_name="Customer support transcripts")

    # Handle response
    print(res)

import { Orq } from "@orq-ai/node";

const orq = new Orq({
  apiKey: process.env["ORQ_API_KEY"] ?? "",
});

async function run() {
  const result = await orq.datasets.create({
    displayName: "Customer support transcripts",
  });

  console.log(result);
}

run();

Show Parameters

{
    "display_name": str,  # required
    "path": Optional[str],
}

{
  displayName: string;  // required
  path?: string;
}

Show Response

{
    "display_name": str,
    "project_id": str,
    "metadata": {
        "total_versions": int,
        "datapoints_count": int,
    },
    "created_by_id": str,
    "updated_by_id": str,
    "created": str,
    "updated": str,
    "workspace_id": str,
    "id": str,
}

{
  displayName: string;
  projectId: string;
  metadata: {
    totalVersions: number;
    datapointsCount: number;
  };
  createdById: string;
  updatedById: string;
  created: string;
  updated: string;
  workspaceId: string;
  id: string;
}

Retrieve a Dataset

Retrieves a specific dataset by its unique identifier.

from orq_ai_sdk import Orq
import os

with Orq(
    api_key=os.getenv("ORQ_API_KEY", ""),
) as orq:

    res = orq.datasets.retrieve(dataset_id="<id>")

    # Handle response
    print(res)

import { Orq } from "@orq-ai/node";

const orq = new Orq({
  apiKey: process.env["ORQ_API_KEY"] ?? "",
});

async function run() {
  const result = await orq.datasets.retrieve({
    datasetId: "<id>",
  });

  console.log(result);
}

run();

Show Parameters

{
    "dataset_id": str,  # required
}

{
  datasetId: string;  // required
}

Show Response

{
    "display_name": str,
    "project_id": str,
    "metadata": {
        "total_versions": int,
        "datapoints_count": int,
    },
    "created_by_id": str,
    "updated_by_id": str,
    "created": str,
    "updated": str,
    "workspace_id": str,
    "id": str,
}

{
  displayName: string;
  projectId: string;
  metadata: {
    totalVersions: number;
    datapointsCount: number;
  };
  createdById: string;
  updatedById: string;
  created: string;
  updated: string;
  workspaceId: string;
  id: string;
}

Delete a Dataset

Permanently deletes a dataset and all its datapoints.

from orq_ai_sdk import Orq
import os

with Orq(
    api_key=os.getenv("ORQ_API_KEY", ""),
) as orq:

    orq.datasets.delete(dataset_id="<id>")

    # Use the SDK ...

import { Orq } from "@orq-ai/node";

const orq = new Orq({
  apiKey: process.env["ORQ_API_KEY"] ?? "",
});

async function run() {
  await orq.datasets.delete({
    datasetId: "<id>",
  });

}

run();

Show Parameters

{
    "dataset_id": str,  # required
}

{
  datasetId: string;  // required
}

Update a Dataset

Updates the specified dataset.

from orq_ai_sdk import Orq
import os

with Orq(
    api_key=os.getenv("ORQ_API_KEY", ""),
) as orq:

    res = orq.datasets.update(dataset_id="<id>", display_name="Customer support transcripts")

    # Handle response
    print(res)

import { Orq } from "@orq-ai/node";

const orq = new Orq({
  apiKey: process.env["ORQ_API_KEY"] ?? "",
});

async function run() {
  const result = await orq.datasets.update({
    datasetId: "<id>",
    updateDatasetRequest: {
      displayName: "Customer support transcripts",
    },
  });

  console.log(result);
}

run();

Show Parameters

{
    "dataset_id": str,  # required
    "display_name": Optional[str],
    "project_id": Optional[str],
}

{
  datasetId: string;  // required
  updateDatasetRequest: {  // required
    displayName?: string;
    projectId?: string;
  };
}

Show Response

{
    "display_name": str,
    "project_id": str,
    "metadata": {
        "total_versions": int,
        "datapoints_count": int,
    },
    "created_by_id": str,
    "updated_by_id": str,
    "created": str,
    "updated": str,
    "workspace_id": str,
    "id": str,
}

{
  displayName: string;
  projectId: string;
  metadata: {
    totalVersions: number;
    datapointsCount: number;
  };
  createdById: string;
  updatedById: string;
  created: string;
  updated: string;
  workspaceId: string;
  id: string;
}

Clear Datasets

Deletes all datapoints from a dataset.

from orq_ai_sdk import Orq
import os

with Orq(
    api_key=os.getenv("ORQ_API_KEY", ""),
) as orq:

    orq.datasets.clear(dataset_id="<id>")

    # Use the SDK ...

import { Orq } from "@orq-ai/node";

const orq = new Orq({
  apiKey: process.env["ORQ_API_KEY"] ?? "",
});

async function run() {
  await orq.datasets.clear({
    datasetId: "<id>",
  });

}

run();

Show Parameters

{
    "dataset_id": str,  # required
}

{
  datasetId: string;  // required
}

List Datapoints

Retrieves a paginated list of datapoints from a specific dataset.

from orq_ai_sdk import Orq
import os

with Orq(
    api_key=os.getenv("ORQ_API_KEY", ""),
) as orq:

    res = orq.datasets.list_datapoints(dataset_id="<id>", limit=10)

    # Handle response
    print(res)

import { Orq } from "@orq-ai/node";

const orq = new Orq({
  apiKey: process.env["ORQ_API_KEY"] ?? "",
});

async function run() {
  const result = await orq.datasets.listDatapoints({
    datasetId: "<id>",
    limit: 10,
  });

  console.log(result);
}

run();

Show Parameters

{
    "dataset_id": str,  # required
    "limit": Optional[int],
    "starting_after": Optional[str],
    "ending_before": Optional[str],
}

{
  datasetId: string;  // required
  limit?: number;
  startingAfter?: string;
  endingBefore?: string;
}

Show Response

{
    "object": str,
    "data": [{
        "inputs": Dict[str, Any],  # optional
        "messages": List[Any],  # optional
        "expected_output": Optional[str],
        "evaluations": List[Any],  # optional
        "dataset_id": str,
        "snapshot_version": Optional[str],
        "created_by_id": str,
        "updated_by_id": str,
        "created": Optional[str],
        "updated": Optional[str],
        "workspace_id": Optional[str],
        "id": str,
    }],
    "has_more": bool,
}

{
  object: string;
  data: {
    inputs?: Record<string, any>;
    messages?: any[];
    expectedOutput?: string;
    evaluations?: any[];
    datasetId: string;
    snapshotVersion?: string;
    createdById: string;
    updatedById: string;
    created?: string;
    updated?: string;
    workspaceId?: string;
    id: string;
  }[];
  hasMore: boolean;
}

Show Variant types

ListDatasetDatapointsEvaluations1

{
    "id": str,
    "evaluation_type": Literal["human_review"],
    "human_review_id": Optional[str],
    "source": Optional[Literal["orq", "external"]],
    "annotator": {  # optional
        "kind": Literal["llm", "code", "human", "automation"],
        "actor_id": str,
    },
    "output_schema": Optional[Literal["boolean", "number", "categorical", "string"]],
    "parent_annotation_id": Optional[str],
    "explanation": Optional[str],
    "reviewed_by_id": str,
    "reviewed_at": str,  # optional
    "type": Literal["string"],
    "value": str,
}

{
  id: string;
  evaluationType: "human_review";
  humanReviewId?: string;
  source?: "orq" | "external";
  annotator?: {
    kind: "llm" | "code" | "human" | "automation";
    actorId: string;
  };
  outputSchema?: "boolean" | "number" | "categorical" | "string";
  parentAnnotationId?: string;
  explanation?: string;
  reviewedById: string;
  reviewedAt?: Date;
  type: "string";
  value: string;
}

ListDatasetDatapointsEvaluations2

{
    "id": str,
    "evaluation_type": Literal["human_review"],
    "human_review_id": Optional[str],
    "source": Optional[Literal["orq", "external"]],
    "annotator": {  # optional
        "kind": Literal["llm", "code", "human", "automation"],
        "actor_id": str,
    },
    "output_schema": Optional[Literal["boolean", "number", "categorical", "string"]],
    "parent_annotation_id": Optional[str],
    "explanation": Optional[str],
    "reviewed_by_id": str,
    "reviewed_at": str,  # optional
    "type": Literal["number"],
    "value": float,
}

{
  id: string;
  evaluationType: "human_review";
  humanReviewId?: string;
  source?: "orq" | "external";
  annotator?: {
    kind: "llm" | "code" | "human" | "automation";
    actorId: string;
  };
  outputSchema?: "boolean" | "number" | "categorical" | "string";
  parentAnnotationId?: string;
  explanation?: string;
  reviewedById: string;
  reviewedAt?: Date;
  type: "number";
  value: number;
}

ListDatasetDatapointsEvaluations3

{
    "id": str,
    "evaluation_type": Literal["human_review"],
    "human_review_id": Optional[str],
    "source": Optional[Literal["orq", "external"]],
    "annotator": {  # optional
        "kind": Literal["llm", "code", "human", "automation"],
        "actor_id": str,
    },
    "output_schema": Optional[Literal["boolean", "number", "categorical", "string"]],
    "parent_annotation_id": Optional[str],
    "explanation": Optional[str],
    "reviewed_by_id": str,
    "reviewed_at": str,  # optional
    "type": Literal["boolean"],
    "value": bool,
}

{
  id: string;
  evaluationType: "human_review";
  humanReviewId?: string;
  source?: "orq" | "external";
  annotator?: {
    kind: "llm" | "code" | "human" | "automation";
    actorId: string;
  };
  outputSchema?: "boolean" | "number" | "categorical" | "string";
  parentAnnotationId?: string;
  explanation?: string;
  reviewedById: string;
  reviewedAt?: Date;
  type: "boolean";
  value: boolean;
}

ListDatasetDatapointsEvaluations4

{
    "id": str,
    "evaluation_type": Literal["human_review"],
    "human_review_id": Optional[str],
    "source": Optional[Literal["orq", "external"]],
    "annotator": {  # optional
        "kind": Literal["llm", "code", "human", "automation"],
        "actor_id": str,
    },
    "output_schema": Optional[Literal["boolean", "number", "categorical", "string"]],
    "parent_annotation_id": Optional[str],
    "explanation": Optional[str],
    "reviewed_by_id": str,
    "reviewed_at": str,  # optional
    "type": Literal["string_array"],
    "values": List[str],
}

{
  id: string;
  evaluationType: "human_review";
  humanReviewId?: string;
  source?: "orq" | "external";
  annotator?: {
    kind: "llm" | "code" | "human" | "automation";
    actorId: string;
  };
  outputSchema?: "boolean" | "number" | "categorical" | "string";
  parentAnnotationId?: string;
  explanation?: string;
  reviewedById: string;
  reviewedAt?: Date;
  type: "string_array";
  values: string[];
}

Create Datapoint

Creates one or more datapoints in the specified dataset.

from orq_ai_sdk import Orq
import os

with Orq(
    api_key=os.getenv("ORQ_API_KEY", ""),
) as orq:

    res = orq.datasets.create_datapoint(dataset_id="<id>", request_body=[
        {
            "inputs": {"question": "How do I reset my password?"},
            "expected_output": "Use the password reset link.",
        },
    ])

    # Handle response
    print(res)

import { Orq } from "@orq-ai/node";

const orq = new Orq({
  apiKey: process.env["ORQ_API_KEY"] ?? "",
});

async function run() {
  const result = await orq.datasets.createDatapoint({
    datasetId: "<id>",
    requestBody: [
      {
        inputs: { question: "How do I reset my password?" },
        expectedOutput: "Use the password reset link.",
      },
    ],
  });

  console.log(result);
}

run();

Show Parameters

{
    "dataset_id": str,  # required
    "request_body": [{  # required
        "inputs": Dict[str, Any],  # optional
        "messages": List[Any],  # optional
        "expected_output": Optional[str],
    }],
}

{
  datasetId: string;  // required
  requestBody: {  // required
    inputs?: Record<string, any>;
    messages?: any[];
    expectedOutput?: string;
  }[];
}

Delete Datapoints

Deletes multiple datapoints from a dataset by ID.

from orq_ai_sdk import Orq
import os

with Orq(
    api_key=os.getenv("ORQ_API_KEY", ""),
) as orq:

    orq.datasets.delete_datapoints(dataset_id="<id>", item_ids=[
        "<value 1>",
    ])

    # Use the SDK ...

import { Orq } from "@orq-ai/node";

const orq = new Orq({
  apiKey: process.env["ORQ_API_KEY"] ?? "",
});

async function run() {
  await orq.datasets.deleteDatapoints({
    datasetId: "<id>",
    deleteDatapointsRequest: {
      itemIds: [
        "<value 1>",
      ],
    },
  });

}

run();

Show Parameters

{
    "dataset_id": str,  # required
    "item_ids": List[str],  # required
}

{
  datasetId: string;  // required
  deleteDatapointsRequest: {  // required
    itemIds: string[];  // required
  };
}

Create Datapoints

Creates multiple datapoints at once.

from orq_ai_sdk import Orq
import os

with Orq(
    api_key=os.getenv("ORQ_API_KEY", ""),
) as orq:

    res = orq.datasets.create_datapoints(dataset_id="<id>", items=[{"inputs": {"question": "How do I reset my password?"}, "expected_output": "Use the password reset link."}])

    # Handle response
    print(res)

import { Orq } from "@orq-ai/node";

const orq = new Orq({
  apiKey: process.env["ORQ_API_KEY"] ?? "",
});

async function run() {
  const result = await orq.datasets.createDatapoints({
    datasetId: "<id>",
    bulkCreateDatapointsRequest: {
      items: [
        {
          inputs: { question: "How do I reset my password?" },
          expectedOutput: "Use the password reset link.",
        },
      ],
    },
  });

  console.log(result);
}

run();

Show Parameters

{
    "dataset_id": str,  # required
    "items": [{  # required
        "inputs": Dict[str, Any],  # optional
        "messages": List[Any],  # optional
        "expected_output": Optional[str],
    }],
}

{
  datasetId: string;  // required
  bulkCreateDatapointsRequest: {  // required
    items: {  // required
      inputs?: Record<string, any>;
      messages?: any[];
      expectedOutput?: string;
    }[];
  };
}

Retrieve Datapoint

Retrieves a datapoint object.

from orq_ai_sdk import Orq
import os

with Orq(
    api_key=os.getenv("ORQ_API_KEY", ""),
) as orq:

    res = orq.datasets.retrieve_datapoint(dataset_id="<id>", datapoint_id="<id>")

    # Handle response
    print(res)

import { Orq } from "@orq-ai/node";

const orq = new Orq({
  apiKey: process.env["ORQ_API_KEY"] ?? "",
});

async function run() {
  const result = await orq.datasets.retrieveDatapoint({
    datasetId: "<id>",
    datapointId: "<id>",
  });

  console.log(result);
}

run();

Show Parameters

{
    "dataset_id": str,  # required
    "datapoint_id": str,  # required
}

{
  datasetId: string;  // required
  datapointId: string;  // required
}

Show Response

{
    "inputs": Dict[str, Any],  # optional
    "messages": List[Any],  # optional
    "expected_output": Optional[str],
    "evaluations": List[Any],  # optional
    "dataset_id": str,
    "snapshot_version": Optional[str],
    "created_by_id": str,
    "updated_by_id": str,
    "created": Optional[str],
    "updated": Optional[str],
    "workspace_id": Optional[str],
    "id": str,
}

{
  inputs?: Record<string, any>;
  messages?: any[];
  expectedOutput?: string;
  evaluations?: any[];
  datasetId: string;
  snapshotVersion?: string;
  createdById: string;
  updatedById: string;
  created?: string;
  updated?: string;
  workspaceId?: string;
  id: string;
}

Show Variant types

RetrieveDatapointEvaluations1

{
    "id": str,
    "evaluation_type": Literal["human_review"],
    "human_review_id": Optional[str],
    "source": Optional[Literal["orq", "external"]],
    "annotator": {  # optional
        "kind": Literal["llm", "code", "human", "automation"],
        "actor_id": str,
    },
    "output_schema": Optional[Literal["boolean", "number", "categorical", "string"]],
    "parent_annotation_id": Optional[str],
    "explanation": Optional[str],
    "reviewed_by_id": str,
    "reviewed_at": str,  # optional
    "type": Literal["string"],
    "value": str,
}

{
  id: string;
  evaluationType: "human_review";
  humanReviewId?: string;
  source?: "orq" | "external";
  annotator?: {
    kind: "llm" | "code" | "human" | "automation";
    actorId: string;
  };
  outputSchema?: "boolean" | "number" | "categorical" | "string";
  parentAnnotationId?: string;
  explanation?: string;
  reviewedById: string;
  reviewedAt?: Date;
  type: "string";
  value: string;
}

RetrieveDatapointEvaluations2

{
    "id": str,
    "evaluation_type": Literal["human_review"],
    "human_review_id": Optional[str],
    "source": Optional[Literal["orq", "external"]],
    "annotator": {  # optional
        "kind": Literal["llm", "code", "human", "automation"],
        "actor_id": str,
    },
    "output_schema": Optional[Literal["boolean", "number", "categorical", "string"]],
    "parent_annotation_id": Optional[str],
    "explanation": Optional[str],
    "reviewed_by_id": str,
    "reviewed_at": str,  # optional
    "type": Literal["number"],
    "value": float,
}

{
  id: string;
  evaluationType: "human_review";
  humanReviewId?: string;
  source?: "orq" | "external";
  annotator?: {
    kind: "llm" | "code" | "human" | "automation";
    actorId: string;
  };
  outputSchema?: "boolean" | "number" | "categorical" | "string";
  parentAnnotationId?: string;
  explanation?: string;
  reviewedById: string;
  reviewedAt?: Date;
  type: "number";
  value: number;
}

RetrieveDatapointEvaluations4

{
    "id": str,
    "evaluation_type": Literal["human_review"],
    "human_review_id": Optional[str],
    "source": Optional[Literal["orq", "external"]],
    "annotator": {  # optional
        "kind": Literal["llm", "code", "human", "automation"],
        "actor_id": str,
    },
    "output_schema": Optional[Literal["boolean", "number", "categorical", "string"]],
    "parent_annotation_id": Optional[str],
    "explanation": Optional[str],
    "reviewed_by_id": str,
    "reviewed_at": str,  # optional
    "type": Literal["string_array"],
    "values": List[str],
}

{
  id: string;
  evaluationType: "human_review";
  humanReviewId?: string;
  source?: "orq" | "external";
  annotator?: {
    kind: "llm" | "code" | "human" | "automation";
    actorId: string;
  };
  outputSchema?: "boolean" | "number" | "categorical" | "string";
  parentAnnotationId?: string;
  explanation?: string;
  reviewedById: string;
  reviewedAt?: Date;
  type: "string_array";
  values: string[];
}

Delete Datapoint

Permanently deletes a specific datapoint from a dataset.

from orq_ai_sdk import Orq
import os

with Orq(
    api_key=os.getenv("ORQ_API_KEY", ""),
) as orq:

    orq.datasets.delete_datapoint(dataset_id="<id>", datapoint_id="<id>")

    # Use the SDK ...

import { Orq } from "@orq-ai/node";

const orq = new Orq({
  apiKey: process.env["ORQ_API_KEY"] ?? "",
});

async function run() {
  await orq.datasets.deleteDatapoint({
    datasetId: "<id>",
    datapointId: "<id>",
  });

}

run();

Show Parameters

{
    "dataset_id": str,  # required
    "datapoint_id": str,  # required
}

{
  datasetId: string;  // required
  datapointId: string;  // required
}

Update Datapoint

Updates the inputs, messages, or expected output for a datapoint.

from orq_ai_sdk import Orq
import os

with Orq(
    api_key=os.getenv("ORQ_API_KEY", ""),
) as orq:

    res = orq.datasets.update_datapoint(dataset_id="<id>", datapoint_id="<id>", expected_output="Use the password reset link.")

    # Handle response
    print(res)

import { Orq } from "@orq-ai/node";

const orq = new Orq({
  apiKey: process.env["ORQ_API_KEY"] ?? "",
});

async function run() {
  const result = await orq.datasets.updateDatapoint({
    datasetId: "<id>",
    datapointId: "<id>",
    updateDatapointRequest: {
      expectedOutput: "Use the password reset link.",
    },
  });

  console.log(result);
}

run();

Show Parameters

{
    "dataset_id": str,  # required
    "datapoint_id": str,  # required
    "inputs": Dict[str, Any],  # optional
    "messages": List[Any],  # optional
    "expected_output": Optional[str],
}

{
  datasetId: string;  // required
  datapointId: string;  // required
  updateDatapointRequest: {  // required
    inputs?: Record<string, any>;
    messages?: any[];
    expectedOutput?: string;
  };
}

Show Response

{
    "inputs": Dict[str, Any],  # optional
    "messages": List[Any],  # optional
    "expected_output": Optional[str],
    "evaluations": List[Any],  # optional
    "dataset_id": str,
    "snapshot_version": Optional[str],
    "created_by_id": str,
    "updated_by_id": str,
    "created": Optional[str],
    "updated": Optional[str],
    "workspace_id": Optional[str],
    "id": str,
}

{
  inputs?: Record<string, any>;
  messages?: any[];
  expectedOutput?: string;
  evaluations?: any[];
  datasetId: string;
  snapshotVersion?: string;
  createdById: string;
  updatedById: string;
  created?: string;
  updated?: string;
  workspaceId?: string;
  id: string;
}

Show Variant types

UpdateDatapointEvaluations1

{
    "id": str,
    "evaluation_type": Literal["human_review"],
    "human_review_id": Optional[str],
    "source": Optional[Literal["orq", "external"]],
    "annotator": {  # optional
        "kind": Literal["llm", "code", "human", "automation"],
        "actor_id": str,
    },
    "output_schema": Optional[Literal["boolean", "number", "categorical", "string"]],
    "parent_annotation_id": Optional[str],
    "explanation": Optional[str],
    "reviewed_by_id": str,
    "reviewed_at": str,  # optional
    "type": Literal["string"],
    "value": str,
}

{
  id: string;
  evaluationType: "human_review";
  humanReviewId?: string;
  source?: "orq" | "external";
  annotator?: {
    kind: "llm" | "code" | "human" | "automation";
    actorId: string;
  };
  outputSchema?: "boolean" | "number" | "categorical" | "string";
  parentAnnotationId?: string;
  explanation?: string;
  reviewedById: string;
  reviewedAt?: Date;
  type: "string";
  value: string;
}

UpdateDatapointEvaluations2

{
    "id": str,
    "evaluation_type": Literal["human_review"],
    "human_review_id": Optional[str],
    "source": Optional[Literal["orq", "external"]],
    "annotator": {  # optional
        "kind": Literal["llm", "code", "human", "automation"],
        "actor_id": str,
    },
    "output_schema": Optional[Literal["boolean", "number", "categorical", "string"]],
    "parent_annotation_id": Optional[str],
    "explanation": Optional[str],
    "reviewed_by_id": str,
    "reviewed_at": str,  # optional
    "type": Literal["number"],
    "value": float,
}

{
  id: string;
  evaluationType: "human_review";
  humanReviewId?: string;
  source?: "orq" | "external";
  annotator?: {
    kind: "llm" | "code" | "human" | "automation";
    actorId: string;
  };
  outputSchema?: "boolean" | "number" | "categorical" | "string";
  parentAnnotationId?: string;
  explanation?: string;
  reviewedById: string;
  reviewedAt?: Date;
  type: "number";
  value: number;
}

UpdateDatapointEvaluations3

{
    "id": str,
    "evaluation_type": Literal["human_review"],
    "human_review_id": Optional[str],
    "source": Optional[Literal["orq", "external"]],
    "annotator": {  # optional
        "kind": Literal["llm", "code", "human", "automation"],
        "actor_id": str,
    },
    "output_schema": Optional[Literal["boolean", "number", "categorical", "string"]],
    "parent_annotation_id": Optional[str],
    "explanation": Optional[str],
    "reviewed_by_id": str,
    "reviewed_at": str,  # optional
    "type": Literal["boolean"],
    "value": bool,
}

{
  id: string;
  evaluationType: "human_review";
  humanReviewId?: string;
  source?: "orq" | "external";
  annotator?: {
    kind: "llm" | "code" | "human" | "automation";
    actorId: string;
  };
  outputSchema?: "boolean" | "number" | "categorical" | "string";
  parentAnnotationId?: string;
  explanation?: string;
  reviewedById: string;
  reviewedAt?: Date;
  type: "boolean";
  value: boolean;
}

UpdateDatapointEvaluations4

{
    "id": str,
    "evaluation_type": Literal["human_review"],
    "human_review_id": Optional[str],
    "source": Optional[Literal["orq", "external"]],
    "annotator": {  # optional
        "kind": Literal["llm", "code", "human", "automation"],
        "actor_id": str,
    },
    "output_schema": Optional[Literal["boolean", "number", "categorical", "string"]],
    "parent_annotation_id": Optional[str],
    "explanation": Optional[str],
    "reviewed_by_id": str,
    "reviewed_at": str,  # optional
    "type": Literal["string_array"],
    "values": List[str],
}

{
  id: string;
  evaluationType: "human_review";
  humanReviewId?: string;
  source?: "orq" | "external";
  annotator?: {
    kind: "llm" | "code" | "human" | "automation";
    actorId: string;
  };
  outputSchema?: "boolean" | "number" | "categorical" | "string";
  parentAnnotationId?: string;
  explanation?: string;
  reviewedById: string;
  reviewedAt?: Date;
  type: "string_array";
  values: string[];
}

Orq SDK

Terminal & Agents

Terraform

Platform APIs

Management APIs

Datasets

List Datasets

Create a Dataset

Retrieve a Dataset

Delete a Dataset

Update a Dataset

Clear Datasets

List Datapoints

ListDatasetDatapointsEvaluations1

ListDatasetDatapointsEvaluations2

ListDatasetDatapointsEvaluations3

ListDatasetDatapointsEvaluations4

Create Datapoint

Delete Datapoints

Create Datapoints

Retrieve Datapoint

RetrieveDatapointEvaluations1

RetrieveDatapointEvaluations2

RetrieveDatapointEvaluations4

Delete Datapoint

Update Datapoint

UpdateDatapointEvaluations1

UpdateDatapointEvaluations2

UpdateDatapointEvaluations3

UpdateDatapointEvaluations4

​Datasets

​List Datasets

​Create a Dataset

​Retrieve a Dataset

​Delete a Dataset

​Update a Dataset

​Clear Datasets

​List Datapoints

​ListDatasetDatapointsEvaluations1

​ListDatasetDatapointsEvaluations2

​ListDatasetDatapointsEvaluations3

​ListDatasetDatapointsEvaluations4

​Create Datapoint

​Delete Datapoints

​Create Datapoints

​Retrieve Datapoint

​RetrieveDatapointEvaluations1

​RetrieveDatapointEvaluations2

​RetrieveDatapointEvaluations4

​Delete Datapoint

​Update Datapoint

​UpdateDatapointEvaluations1

​UpdateDatapointEvaluations2

​UpdateDatapointEvaluations3

​UpdateDatapointEvaluations4

Datasets

List Datasets

Create a Dataset

Retrieve a Dataset

Delete a Dataset

Update a Dataset

Clear Datasets

List Datapoints

ListDatasetDatapointsEvaluations1

ListDatasetDatapointsEvaluations2

ListDatasetDatapointsEvaluations3

ListDatasetDatapointsEvaluations4

Create Datapoint

Delete Datapoints

Create Datapoints

Retrieve Datapoint

RetrieveDatapointEvaluations1

RetrieveDatapointEvaluations2

RetrieveDatapointEvaluations4

Delete Datapoint

Update Datapoint

UpdateDatapointEvaluations1

UpdateDatapointEvaluations2

UpdateDatapointEvaluations3

UpdateDatapointEvaluations4