List Cluster Execution History

Headers

Authorization

string

required

REQUIRED: Bearer token authentication using your API key. Format: 'Bearer sk_xxxxxxxxxxxxx'. You can create API keys in the Mixpeek dashboard under Organization Settings.

X-Namespace

string

required

REQUIRED: Namespace identifier for scoping this request. All resources (collections, buckets, taxonomies, etc.) are scoped to a namespace. You can provide either the namespace name or namespace ID. Format: ns_xxxxxxxxxxxxx (ID) or a custom name like 'my-namespace'

Path Parameters

cluster_id

string

required

Cluster ID

Query Parameters

limit

integer | null

offset

integer | null

Body

application/json

Request parameters for listing and filtering cluster execution history.

Provides flexible querying of historical clustering executions with filtering, sorting, and search capabilities. Use to build execution history UIs, compare runs over time, and analyze clustering performance trends.

Use Cases: - Display execution history table with sorting and filtering - Find failed executions for debugging - Compare metrics across successful runs - Search executions by date range or status - Build execution timeline visualization

Query Behavior: - Empty request {} returns all executions sorted by created_at (newest first) - Filters, sort, and search can be combined for complex queries - Results are paginated (use page/page_size query params)

Note: All fields are OPTIONAL. Omit for default behavior (all executions, newest first).

filters

LogicalOperator · object

OPTIONAL. Complex filtering conditions for execution history. NOT REQUIRED - omit to return all executions. Structure: Logical operator (AND/OR) with array of conditions. Supported filter fields: - status: Filter by execution status (pending/processing/completed/failed). - created_at: Filter by execution start date (use gte/lte for ranges). - num_clusters: Filter by number of clusters found. - metrics.silhouette_score: Filter by quality threshold. Example filters: - Status is completed: {operator: 'AND', conditions: [{field: 'status', value: 'completed', operator: '=='}]}. - Created in last 7 days: {operator: 'AND', conditions: [{field: 'created_at', operator: 'gte', value: '2025-11-06T00:00:00Z'}]}. - Good quality (silhouette > 0.5): {operator: 'AND', conditions: [{field: 'metrics.silhouette_score', operator: '>', value: 0.5}]}. Combine with OR: Status completed OR failed (exclude in-progress).

Show child attributes

filters.AND

FilterCondition · object[] | null

Logical AND operation - all conditions must be true

Represents a single filter condition.

Attributes: field: The field to filter on operator: The comparison operator value: The value to compare against

Show child attributes

filters.AND.field

string

required

Field name to filter on

filters.AND.value

required

Value to compare against

Show child attributes

filters.AND.value.field

string

required

The dot-notation path to the value in the runtime query request, e.g., 'inputs.user_id'

filters.AND.value.type

string

default:dynamic

Allowed value: "dynamic"

filters.AND.operator

enum<string>

default:eq

Comparison operator

Available options:

eq,

ne,

gt,

lt,

gte,

lte,

in,

nin,

contains,

starts_with,

ends_with,

regex,

exists,

is_null,

text

Example:

[
  {
    "field": "name",
    "operator": "eq",
    "value": "John"
  },
  {
    "field": "age",
    "operator": "gte",
    "value": 30
  }
]

filters.OR

FilterCondition · object[] | null

Logical OR operation - at least one condition must be true

Represents a single filter condition.

Attributes: field: The field to filter on operator: The comparison operator value: The value to compare against

Show child attributes

filters.OR.field

string

required

Field name to filter on

filters.OR.value

required

Value to compare against

Show child attributes

filters.OR.value.field

string

required

The dot-notation path to the value in the runtime query request, e.g., 'inputs.user_id'

filters.OR.value.type

string

default:dynamic

Allowed value: "dynamic"

filters.OR.operator

enum<string>

default:eq

Comparison operator

Available options:

eq,

ne,

gt,

lt,

gte,

lte,

in,

nin,

contains,

starts_with,

ends_with,

regex,

exists,

is_null,

text

Example:

[
  {
    "field": "status",
    "operator": "eq",
    "value": "active"
  },
  {
    "field": "role",
    "operator": "eq",
    "value": "admin"
  }
]

filters.NOT

FilterCondition · object[] | null

Logical NOT operation - all conditions must be false

Represents a single filter condition.

Attributes: field: The field to filter on operator: The comparison operator value: The value to compare against

Show child attributes

filters.NOT.field

string

required

Field name to filter on

filters.NOT.value

required

Value to compare against

Show child attributes

filters.NOT.value.field

string

required

The dot-notation path to the value in the runtime query request, e.g., 'inputs.user_id'

filters.NOT.value.type

string

default:dynamic

Allowed value: "dynamic"

filters.NOT.operator

enum<string>

default:eq

Comparison operator

Available options:

eq,

ne,

gt,

lt,

gte,

lte,

in,

nin,

contains,

starts_with,

ends_with,

regex,

exists,

is_null,

text

Example:

[
  {
    "field": "department",
    "operator": "eq",
    "value": "HR"
  },
  {
    "field": "location",
    "operator": "eq",
    "value": "remote"
  }
]

filters.case_sensitive

boolean | null

default:false

Whether to perform case-sensitive matching

Example:

true

sort

SortOption · object

OPTIONAL. Sorting configuration for results. NOT REQUIRED - defaults to created_at descending (newest first). Structure: {field: 'field_name', direction: 'asc' or 'desc'}. Sortable fields: - created_at: Sort by execution start time (default). - completed_at: Sort by execution finish time. - num_clusters: Sort by cluster count. - num_points: Sort by document count. - metrics.silhouette_score: Sort by quality score. - status: Sort by execution status. Common use cases: - Newest first (default): {field: 'created_at', direction: 'desc'}. - Best quality first: {field: 'metrics.silhouette_score', direction: 'desc'}. - Failed executions first: {field: 'status', direction: 'asc'} (alphabetical).

Show child attributes

sort.field

string

required

Field to sort by, supports dot notation for nested fields

Example:

"created_at"

sort.direction

enum<string>

default:asc

Sort direction

Available options:

asc,

desc

Example:

"desc"

string | null

OPTIONAL. Full-text search query across execution metadata. NOT REQUIRED - omit for no search filtering. Searches in: - run_id: Search by execution identifier. - error_message: Find executions with specific error text. - centroids.label: Search by cluster label names. - centroids.summary: Search by cluster descriptions. Behavior: - Case-insensitive partial matching. - Multiple terms are AND-ed together. - Combines with filters for complex queries. Examples: - 'failed' → Find executions with 'failed' in error messages. - 'product review' → Find executions with clusters about products/reviews. - 'run_abc123' → Find specific execution by ID.

Example:

"failed"

Response

Successful Response

Complete response for cluster execution history listing endpoint.

Returns paginated execution history with filtering, sorting, and aggregate statistics. Use to build execution history UIs, monitoring dashboards, and performance analytics.

Response Structure: - results: Array of execution details (paginated) - pagination: Page navigation info (current page, total pages, etc.) - total_count: Total matching executions (across all pages) - stats: Aggregated metrics for current result set

Use Cases: - Build execution history table with pagination - Display execution status dashboard with charts - Monitor clustering performance trends - Debug failed executions - Compare quality metrics across runs

Pagination Behavior: - Default: 10 executions per page - Use query params: ?page=1&page_size=20 - results contains current page only - total_count shows all matching executions - pagination provides navigation links

Example Workflow: 1. Request: POST /clusters/{id}/executions/list with filters 2. Response: 50 total executions, showing page 1 (10 results) 3. Display: Show 10 results + "Page 1 of 5" + aggregate stats 4. Navigate: Use pagination.next_page for next 10 results

results

ClusterExecutionResult · object[]

required

REQUIRED. Array of cluster execution results for the current page. Length: 0 to page_size (default 10, max typically 100). Empty array [] if: - No executions exist for this cluster. - Filters matched no results. - Requested page beyond available pages. Sorted by: created_at descending (newest first) by default. Override with sort parameter in request. Each item contains: - run_id: Unique execution identifier. - status: pending/processing/completed/failed. - num_clusters: Clusters found. - metrics: Quality scores (if available). - centroids: Cluster labels and summaries (if available). - created_at/completed_at: Timestamps. - error_message: Error details (if failed). Use for: Rendering execution history table rows.

Show child attributes

results.run_id

string

required

REQUIRED. Unique identifier for this specific clustering execution. Format: 'run_' prefix followed by random alphanumeric string. Used to retrieve specific execution artifacts and results. Each re-execution of the same cluster creates a new run_id. References execution artifacts in S3 and MongoDB.

results.cluster_id

string

required

REQUIRED. Parent cluster configuration that was executed. Format: 'clust_' prefix followed by random alphanumeric string. Links this execution back to the cluster definition. Multiple executions can share the same cluster_id.

results.status

enum<string>

required

REQUIRED. Current status of the clustering execution. Values: 'pending' = Job queued, waiting to start. 'processing' = Clustering algorithm running (may take minutes for large datasets). 'completed' = Clustering finished successfully, results available. 'failed' = Clustering failed, check error_message for details. Status changes: pending → processing → (completed OR failed). Poll this field to track job progress.

Available options:

pending,

processing,

completed,

failed

results.num_clusters

integer

required

REQUIRED. Number of clusters found by the clustering algorithm. Range: 1 to num_points (though typically much lower). Interpretation: Too few clusters = overgeneralization, may need lower n_clusters param. Too many clusters = overfitting, may need higher n_clusters param. Optimal value depends on dataset and use case. Available immediately upon completion, even if metrics fail.

Required range: x >= 0

results.num_points

integer

required

REQUIRED. Total number of documents/points that were clustered. Equals the count of documents in the collection at execution time. Note: This may differ across executions if documents were added/removed. Used to calculate metrics and validate clustering quality. Minimum 2 points required for clustering (1 cluster per point otherwise).

Required range: x >= 0

results.created_at

string<date-time>

required

REQUIRED. Timestamp when the clustering execution started. ISO 8601 format with timezone (UTC). Used to: - Sort executions chronologically. - Calculate execution duration (completed_at - created_at). - Filter execution history by date range. Always present, even for failed executions.

results.metrics

ClusterExecutionMetrics · object

OPTIONAL. Quality metrics evaluating clustering performance. NOT REQUIRED - only present for successful executions. null if: - Execution is still pending/processing. - Execution failed. - Too few points to calculate metrics (need 2+ points). Contains silhouette_score, davies_bouldin_index, calinski_harabasz_score. Use to compare quality across multiple executions.

Show child attributes

results.metrics.silhouette_score

number | null

OPTIONAL. Silhouette score measuring cluster cohesion and separation. Range: -1 to +1. Interpretation: +1.0 = Perfect clustering (documents far from other clusters, close to own cluster). 0.0 = Overlapping clusters (documents on cluster boundaries). -1.0 = Poor clustering (documents assigned to wrong clusters). Practical thresholds: 0.7 to 1.0 = Excellent clustering. 0.5 to 0.7 = Good clustering. 0.25 to 0.5 = Weak clustering, consider different parameters. Below 0.25 = Poor clustering, reconfigure or more data needed. null = metric not calculated (too few points or clustering failed).

Required range: -1 <= x <= 1

Example:

0.85

results.metrics.davies_bouldin_index

number | null

OPTIONAL. Davies-Bouldin index measuring cluster separation. Range: 0 to +∞ (lower is better, no upper bound). Interpretation: 0.0 = Perfect separation (impossible in practice). 0.0 to 1.0 = Excellent separation. 1.0 to 2.0 = Good separation. Above 2.0 = Poor separation, clusters overlap. Formula: Average ratio of intra-cluster to inter-cluster distances. Use when: Validating that clusters are distinct and well-separated. null = metric not calculated (too few points or clustering failed).

Required range: x >= 0

Example:

0.45

results.metrics.calinski_harabasz_score

number | null

OPTIONAL. Calinski-Harabasz score (also called Variance Ratio Criterion). Range: 0 to +∞ (higher is better, no strict upper bound). Interpretation: Higher values indicate denser, more compact clusters. No universal threshold - compare relative values across runs. Typical good values: 100-1000+ (dataset dependent). Formula: Ratio of between-cluster to within-cluster dispersion. Use when: Comparing different numbers of clusters for the same dataset. Note: Biased toward algorithms that produce spherical, equally-sized clusters. null = metric not calculated (too few points or clustering failed).

Required range: x >= 0

Example:

456.78

Example:

{
  "calinski_harabasz_score": 1234.56,
  "davies_bouldin_index": 0.42,
  "description": "Excellent clustering quality",
  "silhouette_score": 0.85
}

results.centroids

ClusterExecutionCentroid · object[] | null

OPTIONAL. List of cluster centroids with semantic labels. NOT REQUIRED - only present for completed executions with LLM labeling enabled. Length: equals num_clusters. Each centroid contains: - cluster_id: Identifier for the cluster (e.g., 'cl_0'). - num_members: Count of documents in this cluster. - label: Human-readable cluster name (e.g., 'Product Reviews'). - summary: Brief description of cluster content. - keywords: Array of representative terms. null if: - Execution pending/processing/failed. - LLM labeling not configured. Use for: Displaying cluster summaries in UI, filtering by cluster.

Show child attributes

results.centroids.cluster_id

string

required

REQUIRED. Unique identifier for this cluster within the execution. Format: 'cl_' prefix followed by numeric index (e.g., 'cl_0', 'cl_1'). Used to reference this specific cluster in queries and enrichments. Consistent across executions if algorithm deterministic.

results.centroids.num_members

integer

required

REQUIRED. Number of documents/points assigned to this cluster. Indicates cluster size for sizing bubbles in visualizations. Minimum: 1 (K-Means forces assignment). Can be 0 for noise clusters in HDBSCAN (cluster_id = -1).

Required range: x >= 0

results.centroids.label

string | null

OPTIONAL. Human-readable label generated by LLM (e.g., GPT-4o-mini). Automatically generated when llm_labeling.enabled = true in cluster config. NOT REQUIRED when LLM labeling disabled. Describes the semantic meaning of documents in this cluster. Example: 'Product Reviews', 'Technical Documentation', 'Customer Support'.

Example:

"Product Reviews"

results.centroids.summary

string | null

OPTIONAL. Detailed description generated by LLM. Automatically generated when llm_labeling.include_summary = true. NOT REQUIRED when LLM labeling disabled or summary not requested. Provides context about what types of documents are in this cluster. Useful for tooltips, expanded views, or detailed explanations.

Example:

"This cluster contains documents related to product reviews and customer feedback."

results.centroids.keywords

string[] | null

OPTIONAL. List of semantic keywords generated by LLM. Automatically generated when llm_labeling.include_keywords = true. NOT REQUIRED when LLM labeling disabled or keywords not requested. Useful for search, filtering, and quick cluster understanding. Typically 3-5 keywords per cluster.

Example:

["reviews", "products", "feedback"]

results.completed_at

string<date-time> | null

OPTIONAL. Timestamp when the clustering execution finished. ISO 8601 format with timezone (UTC). NOT REQUIRED - only present for completed or failed executions. null if: status is 'pending' or 'processing'. Use to: - Calculate execution duration (completed_at - created_at). - Show when results became available. Present for both successful and failed executions.

Example:

"2025-11-13T13:25:40.122000Z"

results.error_message

string | null

OPTIONAL. Error message if the clustering execution failed. NOT REQUIRED - only present when status is 'failed'. null if: execution succeeded or is still in progress. Contains: - Human-readable error description. - Possible causes and suggested fixes. - Stack trace details (for debugging). Common errors: - 'Insufficient documents for clustering' (need 2+ docs). - 'Feature extractor not found' (invalid collection config). - 'Out of memory' (dataset too large for algorithm). Use for: Debugging failed executions and user error messages.

Example:

"Insufficient documents for clustering: need at least 2 documents"

results.llm_labeling_errors

string[] | null

OPTIONAL. List of errors encountered during LLM labeling. NOT REQUIRED - only present when LLM labeling was attempted and encountered errors. null if: - LLM labeling was not enabled. - LLM labeling succeeded for all clusters. - Execution is still in progress. Each error is a JSON string containing: - 'error': Human-readable error message. - 'clusters': List of cluster IDs affected by this error. Common errors: - 'LLM API timeout for 2 clusters' (network/API issues). - 'OpenAI rate limit exceeded' (quota exhausted). - 'Invalid model name: gpt-3.5' (config error). - 'No representative documents for cluster cl_3' (empty cluster). Use for: - Debugging why some clusters have fallback labels. - Identifying LLM API issues without failing entire clustering. - Warning users about partial labeling success.

Example:

[
  "{\"error\": \"LLM API timeout\", \"clusters\": [\"cl_3\", \"cl_5\"]}",
  "{\"error\": \"No representative documents\", \"clusters\": [\"cl_1\"]}"
]

pagination

PaginationResponse · object

required

REQUIRED. Pagination metadata for navigating result pages. Contains: - total: Total items across all pages (same as total_count). - page: Current page number (1-indexed). - page_size: Items per page. - total_pages: Total number of pages. - next_page: URL for next page (null if last page). - previous_page: URL for previous page (null if first page). Use for: - Pagination controls ('Page 2 of 5'). - Next/Previous buttons (check null for disabled state). - Showing X-Y of Z results calculations.

Show child attributes

pagination.total

integer

required

pagination.page

integer

required

pagination.page_size

integer

required

pagination.total_pages

integer

required

pagination.next_page

string | null

pagination.previous_page

string | null

total_count

integer

required

REQUIRED. Total number of executions matching the query across ALL pages. Use for: - Display total count ('Found 127 executions'). - Calculate pagination ('Showing 1-10 of 127'). - Validate filters (0 = no matches, refine query). Behavior: - Includes all filtered results, not just current page. - Changes when filters are applied. - Equals len(results) only if all results fit on one page. Example: - Query returns 127 executions total. - Page size = 10. - Current page (1) shows results[0:10]. - total_count = 127 (not 10).

Required range: x >= 0

stats

ClusterExecutionListStats · object

OPTIONAL. Aggregate statistics for executions in current result set. NOT REQUIRED - may be null if stats calculation disabled. Typically always provided for execution listing. Contains: - total_executions: Count in current page. - executions_by_status: Status distribution {'completed': 45, 'failed': 3}. - avg_execution_time_ms: Mean duration. - total_documents_clustered: Sum of all processed documents. - avg_num_clusters: Mean clusters per execution. Use for: - Summary cards above table. - Status pie chart. - Performance metrics dashboard. Note: - Stats calculated for current page only (or all if no pagination). - Respects filters (stats for filtered subset).

Show child attributes

stats.total_executions

integer

default:0

OPTIONAL (always provided). Total number of executions in current result set. Equals length of results array. Use for: - Display total count in UI ('Showing 10 of 100 executions'). - Validate pagination (total should match page_size × pages). - Check if filters returned any results (0 = no matches). Note: This is the count in the current page, not all executions.

Required range: x >= 0

stats.executions_by_status

Executions By Status · object

OPTIONAL (always provided). Count of executions grouped by status. Keys: 'pending', 'processing', 'completed', 'failed'. Values: Number of executions in each status. Use for: - Status distribution chart (pie/bar chart). - Health monitoring (high failed count = problem). - Progress tracking (pending + processing = in-flight jobs). Example: {'completed': 45, 'failed': 3, 'processing': 2, 'pending': 0}. Empty dict {} if no executions in result set.

Show child attributes

stats.executions_by_status.{key}

integer

stats.avg_execution_time_ms

number

default:0

OPTIONAL (always provided). Average execution duration in milliseconds. Calculated as: mean(completed_at - created_at) for completed/failed executions. Excludes pending/processing executions (no completed_at yet). Use for: - Performance monitoring ('Average: 5.2 seconds'). - Trend analysis (is clustering getting slower over time?). - Capacity planning (estimate time for future runs). 0.0 if: No completed/failed executions in result set. Typical values: - Small datasets (< 100 docs): 1000-5000ms (1-5 seconds). - Medium datasets (100-1000 docs): 5000-30000ms (5-30 seconds). - Large datasets (1000+ docs): 30000-300000ms (30 seconds - 5 minutes).

Required range: x >= 0

stats.total_documents_clustered

integer

default:0

OPTIONAL (always provided). Total documents processed across all executions. Calculated as: sum(num_points) for all executions in result set. Use for: - Volume tracking ('Processed 10,000 documents'). - Cost estimation (larger datasets = more compute). - Data growth monitoring (compare over time). 0 if: No executions in result set. Note: Same document may be counted multiple times if re-clustered.

Required range: x >= 0

stats.avg_num_clusters

number

default:0

OPTIONAL (always provided). Average number of clusters found per execution. Calculated as: mean(num_clusters) for all executions in result set. Use for: - Clustering consistency check (stable avg = consistent results). - Algorithm tuning (avg too high/low may need parameter adjustment). - Trend analysis (is clustering finding more/fewer clusters over time?). 0.0 if: No executions in result set. Typical values: - Under-clustering: < 3 clusters (data may be too diverse). - Good clustering: 3-20 clusters (manageable, meaningful groups). - Over-clustering: > 20 clusters (too granular, hard to interpret).

Required range: x >= 0

Example:

{
  "avg_execution_time_ms": 8234.5,
  "avg_num_clusters": 5.2,
  "description": "Healthy execution stats (mostly successful)",
  "executions_by_status": {
    "completed": 45,
    "failed": 3,
    "pending": 0,
    "processing": 2
  },
  "total_documents_clustered": 50000,
  "total_executions": 50
}

Health

Organizations

Namespaces

Buckets

Feature Extractors

Collections

Retrievers

Taxonomies

Clusters

Templates

Analytics

Resource Search

Inference

Agent Sessions

Tasks

Webhooks

Notifications

Triggers

List Cluster Execution History

Headers

Path Parameters

Query Parameters

Body

Response