mixpeek 0.81.1

package/dist/models/stage-params-json-transform.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Mixpeek API
+ * This is the Mixpeek API, providing access to various endpoints for data processing and retrieval.
+ *
+ * The version of the OpenAPI document: 0.81.1
+ * Contact: info@mixpeek.com
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+/**
+ * Configuration for JSON Jinja template transformation stage.  Stage Category: APPLY (1-1 transformation)  Transformation: N documents → N documents (or fewer with fail_on_error=False)  Purpose: Applies a Jinja2 template to each document in the retrieval pipeline, rendering the template with full document context and replacing the document with the parsed JSON output. Useful for reformatting documents to match external API schemas or restructuring data for downstream consumers.  Performance: Template rendering is fast (<1ms per document). No caching is implemented as re-rendering is faster than cache overhead for typical document sizes. Processes documents sequentially with error handling.  When to Use:     - Reformat documents for external API calls (webhooks, workflows)     - Rename or reorganize document fields for client consumption     - Drop unnecessary properties to reduce response size     - Expand or flatten nested arrays/objects     - Apply conditional field inclusion based on document values     - Create custom response schemas from standard document format  When NOT to Use:     - For filtering documents (use FILTER stages: structured_filter, llm_filter)     - For sorting documents (use SORT stages: sort_relevance, rerank)     - For enriching with new data (use APPLY stages: document_enrich)     - For joining external data (use APPLY 1-N stages: taxonomy_enrich)  Template Context:     Templates have access to the full retriever template context:     - DOC (or doc): Current document fields and metadata     - INPUT (or input/inputs): Original query inputs from the search request     - CONTEXT (or context): Execution context (namespace_id, internal_id, etc.)     - STAGE (or stage): Current stage execution data and metadata  Template Features:     - Standard Jinja2 syntax with all built-in filters (tojson, length, etc.)     - Conditional logic ({% if %}, {% elif %}, {% else %})     - Loops and iteration ({% for item in items %})     - Variable access with dot notation (DOC.metadata.field)     - JSON filters for proper escaping ({{ value | tojson }})  Error Handling:     Documents that fail template rendering or JSON parsing can either     skip with a warning (default) or fail the entire retrieval pipeline.     Failed documents are tracked in stage metadata for observability.  Operational Behavior:     - Fast stage: runs in API layer (no Engine delegation)     - Sequential processing: documents transformed one at a time     - Error isolation: one document failure doesn\'t affect others (unless fail_on_error=True)     - Schema replacement: output schema completely defined by template     - Reports metrics to ClickHouse for performance monitoring  Common Pipeline Position: FILTER → SORT → APPLY (this stage)  Requirements:     - template: REQUIRED     - fail_on_error: OPTIONAL (defaults to False)  Use Cases:     - External API formatting: Format documents for webhook payloads     - Response optimization: Remove unused fields to reduce bandwidth     - Schema adaptation: Convert internal format to client-specific format     - Conditional outputs: Include fields based on document properties     - Array flattening: Transform nested structures to flat arrays  Examples:     Basic field selection and renaming:     >>> template = \'{\"id\": \"{{ DOC.document_id }}\", \"text\": \"{{ DOC.content }}\"}\'      Conditional field inclusion for external API:     >>> template = \'\'\'     ... {     ...   \"workflow\": \"{{ DOC.workflow_name }}\",     ...   \"inputs\": [     ...     {\"name\": \"variant_id\", \"value\": \"{{ DOC.variant_id }}\"}     ...     {% if DOC.asset_type == \"VIDEO\" %},     ...     {\"name\": \"video\", \"value\": {\"src\": \"{{ DOC.asset_url }}\"}}     ...     {% endif %}     ...   ]     ... }     ... \'\'\'      Array expansion with iteration:     >>> template = \'\'\'     ... {     ...   \"items\": [     ...     {% for item in DOC.tags %}     ...     \"{{ item }}\"{% if not loop.last %},{% endif %}     ...     {% endfor %}     ...   ]     ... }     ... \'\'\'      Nested field access and JSON escaping:     >>> template = \'{\"user\": \"{{ DOC.metadata.user_id }}\", \"data\": {{ DOC.raw_data | tojson }}}\'
+ * @export
+ * @interface StageParamsJsonTransform
+ */
+export interface StageParamsJsonTransform {
+    [key: string]: any;
+    /**
+     * Jinja2 template string that must render to valid JSON. The template has access to full retriever context: - DOC (or doc): Current document fields and metadata - INPUT (or input/inputs): Original query inputs from search request - CONTEXT (or context): Execution context (namespace_id, internal_id) - STAGE (or stage): Current stage execution data Both uppercase and lowercase namespace formats work identically (DOC == doc). The template must produce valid JSON syntax when rendered - invalid JSON will cause document to be skipped (unless fail_on_error=True). Supports all Jinja2 features: conditionals ({% if %}), loops ({% for %}), filters (| tojson, | length), variable access (DOC.metadata.field). Common patterns: - Field selection: {\'id\': \'{{ DOC.document_id }}\'} - Conditional inclusion: {% if DOC.type == \'video\' %}...{% endif %} - Array iteration: {% for item in DOC.tags %}...{% endfor %} - JSON escaping: {{ DOC.data | tojson }} Use cases: API formatting, field renaming, property filtering, structure flattening.
+     * @type {string}
+     * @memberof StageParamsJsonTransform
+     */
+    'template'?: string;
+    /**
+     * OPTIONAL. Whether to fail the entire retrieval pipeline if any document transformation fails. Default: False. False (default): Skip failed documents with warning logged, continue processing remaining documents. Failed documents are tracked in stage metadata for observability and debugging. Use for lenient pipelines where partial results are acceptable (e.g., best-effort reformatting). True: Fail entire retrieval on first transformation error. Use for strict pipelines where all documents must transform successfully (e.g., critical API integrations where incomplete data would cause downstream failures). Failure causes: invalid template syntax, template rendering errors (missing fields), invalid JSON output from template, document missing required fields. Typical values: False for public APIs (resilient), True for internal workflows (data integrity critical).
+     * @type {boolean}
+     * @memberof StageParamsJsonTransform
+     */
+    'fail_on_error'?: boolean;
+}
+//# sourceMappingURL=stage-params-json-transform.d.ts.map

package/dist/models/stage-params-json-transform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stage-params-json-transform.d.ts","sourceRoot":"","sources":["../../models/stage-params-json-transform.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AAIH;;;;GAIG;AACH,MAAM,WAAW,wBAAwB;IACrC,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;IAEnB;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;;OAIG;IACH,eAAe,CAAC,EAAE,OAAO,CAAC;CAC7B"}

package/dist/models/stage-params-llm-enrich.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Mixpeek API
+ * This is the Mixpeek API, providing access to various endpoints for data processing and retrieval.
+ *
+ * The version of the OpenAPI document: 0.81.1
+ * Contact: info@mixpeek.com
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+import type { StageDefsLLMProvider } from './stage-defs-llmprovider';
+import type { StageDefsLogicalOperator } from './stage-defs-logical-operator';
+/**
+ * Configuration for augmenting documents with LLM generated fields.  **Stage Category**: APPLY (1-1 Enrichment/Generation)  **Transformation**: N documents → N documents (same count, expanded schema)  **Purpose**: Applies LLM generation to each input document, creating new fields with generated content. Use this for summaries, insights, descriptions, or transformations. Each input document produces exactly one output document with added generated fields.  **When to Use**:     - After FILTER/SORT to enhance final results with generated content     - For summarization of long content     - To extract structured data (entities, insights, key points)     - For content transformation (translation, rephrasing, formatting)     - To generate descriptions, titles, or metadata     - For creative augmentation (suggestions, recommendations)  **When NOT to Use**:     - For removing documents (use FILTER: llm_filter instead)     - For simple field transformations (use direct field mapping)     - For initial document retrieval (use FILTER: hybrid_search)     - For reordering (use SORT stages)     - When fast response time is critical (LLM generation is slow, 200ms-5s)     - When cost is a major concern (LLM generation is very expensive)     - For large batch processing (consider async batch jobs instead)  **Operational Behavior**:     - Applies LLM generation to each input document (1-1 operation)     - Maintains document count: N in → N out     - Expands schema: adds new generated fields to each document     - Makes HTTP requests to Engine service for LLM inference     - Very slow operation (LLM generation, 200ms-5s per document batch)     - Processes documents in batches to optimize throughput     - Supports concurrent batching for parallel LLM calls  **Common Pipeline Position**: FILTER → SORT → APPLY (this stage)  **Cost & Performance**:     - Very Expensive: LLM generation costs per document (10-100x vs embeddings)     - Very Slow: 200ms-5s per batch depending on LLM and generation length     - CRITICAL: Use `when` parameter for selective enrichment (massive cost savings)     - Consider enriching only top-ranked results after RANK stage     - Smaller batch sizes often better for latency  **Conditional Enrichment**: Supports `when` parameter to only enrich specific documents. CRITICAL FOR COST SAVINGS - LLM generation is expensive!     - Only summarize long documents (word_count > 500)     - Only process high-priority items     - Only enrich specific content types (articles, not images)  Requirements:     - provider: OPTIONAL, LLM provider (openai, google, anthropic). Auto-inferred if not specified.     - model_name: OPTIONAL, specific model name. Uses provider default if not specified.     - prompt: REQUIRED, LLM prompt template (supports {DOC.field}, {INPUT.field})     - output_field: REQUIRED, where to store generated content     - batch_size: OPTIONAL, documents per batch (default 5)     - schema: OPTIONAL, JSON schema for structured output     - when: OPTIONAL but RECOMMENDED for cost control  Use Cases:     - Summarization: Generate 3-sentence summaries of articles     - Insight extraction: Extract key takeaways and insights     - Description generation: Create product descriptions from specs     - Translation: Translate content to other languages     - Entity extraction: Extract people, places, organizations     - Recommendation generation: Create personalized suggestions  Examples:     Unconditional enrichment:         ```json         {             \"provider\": \"openai\",             \"model_name\": \"gpt-4o-mini\",             \"prompt\": \"Summarize the document\",             \"output_field\": \"metadata.summary\"         }         ```      Conditional enrichment (only summarize long documents):         ```json         {             \"provider\": \"google\",             \"model_name\": \"gemini-2.5-flash\",             \"prompt\": \"Summarize the document\",             \"output_field\": \"metadata.summary\",             \"when\": {                 \"field\": \"metadata.word_count\",                 \"operator\": \"gt\",                 \"value\": 500             }         }         ```
+ * @export
+ * @interface StageParamsLlmEnrich
+ */
+export interface StageParamsLlmEnrich {
+    /**
+     * LLM provider to use. Supported providers: - openai: GPT models (GPT-4o, GPT-4o-mini) - google: Gemini models (Gemini 2.5 Flash) - anthropic: Claude models (Claude 3.5 Sonnet/Haiku)  If not specified, defaults to \'google\'. Can be auto-inferred from model_name.
+     * @type {StageDefsLLMProvider}
+     * @memberof StageParamsLlmEnrich
+     */
+    'provider'?: StageDefsLLMProvider;
+    /**
+     * Specific LLM model to use. If not specified, uses provider default. Examples: gemini-2.5-flash, gpt-4o-mini, claude-3-5-haiku-20241022
+     * @type {string}
+     * @memberof StageParamsLlmEnrich
+     */
+    'model_name'?: string;
+    /**
+     * DEPRECATED: Use \'provider\' and \'model_name\' instead. Legacy format: \'provider:model\' (e.g., \'gemini:gemini-2.5-flash\'). Kept for backward compatibility only.
+     * @type {string}
+     * @memberof StageParamsLlmEnrich
+     * @deprecated
+     */
+    'inference_name'?: string;
+    /**
+     * Prompt template for the LLM (supports doc/input templates).
+     * @type {string}
+     * @memberof StageParamsLlmEnrich
+     */
+    'prompt'?: string;
+    /**
+     * Dot-path where the enrichment result should be stored.
+     * @type {string}
+     * @memberof StageParamsLlmEnrich
+     */
+    'output_field'?: string;
+    /**
+     * Number of documents to enrich per LLM request batch.
+     * @type {number}
+     * @memberof StageParamsLlmEnrich
+     */
+    'batch_size'?: number;
+    /**
+     * Optional JSON schema instructions for the LLM output.
+     * @type {{ [key: string]: any; }}
+     * @memberof StageParamsLlmEnrich
+     */
+    'schema'?: {
+        [key: string]: any;
+    };
+    /**
+     * Maximum output tokens for the LLM response. If not specified, uses the provider default (4000). Increase this if output is being truncated. Note: Gemini counts tokens more aggressively than Claude/GPT — a 1000-token limit may produce only ~350 characters with Gemini.
+     * @type {number}
+     * @memberof StageParamsLlmEnrich
+     */
+    'max_tokens'?: number;
+    /**
+     * Sampling temperature passed to the LLM.
+     * @type {number}
+     * @memberof StageParamsLlmEnrich
+     */
+    'temperature'?: number;
+    /**
+     * OPTIONAL. Bring Your Own Key (BYOK) - use your own LLM API key instead of Mixpeek\'s.  **How to use:** 1. Store your API key as an organization secret via POST /v1/organizations/secrets    Example: {\"secret_name\": \"openai_api_key\", \"secret_value\": \"sk-proj-...\"}  2. Reference it here using template syntax: {{secrets.openai_api_key}}  **Benefits:** - Use your own API credits and rate limits - Keep your API keys secure in Mixpeek\'s encrypted vault - No changes needed to your retriever when rotating keys  If not provided, uses Mixpeek\'s default API keys (usage charged to your account).
+     * @type {string}
+     * @memberof StageParamsLlmEnrich
+     */
+    'api_key'?: string;
+    /**
+     * Whether to use semantic caching (vCache) for LLM calls in this stage. When True, semantically similar prompts return cached responses, reducing cost. When False, every call goes directly to the LLM provider, reducing latency. When None (default), falls back to the global VCACHE_ENABLED setting.
+     * @type {boolean}
+     * @memberof StageParamsLlmEnrich
+     */
+    'use_vcache'?: boolean;
+    /**
+     * OPTIONAL. Conditional filter that documents must satisfy to be enriched with LLM. Uses LogicalOperator (AND/OR/NOT) for complex boolean logic, or simple field/operator/value for single conditions. Documents NOT matching this condition will SKIP enrichment (pass-through unchanged). CRITICAL FOR COST SAVINGS - LLM calls are expensive! Only enrich documents that need it. When NOT specified, ALL documents are enriched unconditionally (may incur high costs).   Use cases: - Only summarize documents with word_count > 500 - Only enrich English articles/blogs - Only process high-priority items   Simple condition example: {\"field\": \"metadata.word_count\", \"operator\": \"gt\", \"value\": 500} Boolean AND example: {\"AND\": [{\"field\": \"category\", \"operator\": \"in\", \"value\": [\"article\"]}, ...]}
+     * @type {StageDefsLogicalOperator}
+     * @memberof StageParamsLlmEnrich
+     */
+    'when'?: StageDefsLogicalOperator;
+}
+//# sourceMappingURL=stage-params-llm-enrich.d.ts.map

package/dist/models/stage-params-llm-enrich.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stage-params-llm-enrich.d.ts","sourceRoot":"","sources":["../../models/stage-params-llm-enrich.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AAKH,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAGrE,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,+BAA+B,CAAC;AAE9E;;;;GAIG;AACH,MAAM,WAAW,oBAAoB;IACjC;;;;OAIG;IACH,UAAU,CAAC,EAAE,oBAAoB,CAAC;IAClC;;;;OAIG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;;;OAKG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B;;;;OAIG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;;;;OAIG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB;;;;OAIG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;;OAIG;IACH,QAAQ,CAAC,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;KAAE,CAAC;IACnC;;;;OAIG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;;OAIG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB;;;;OAIG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;;OAIG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB;;;;OAIG;IACH,MAAM,CAAC,EAAE,wBAAwB,CAAC;CACrC"}

package/dist/models/stage-params-llm-filter.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Mixpeek API
+ * This is the Mixpeek API, providing access to various endpoints for data processing and retrieval.
+ *
+ * The version of the OpenAPI document: 0.81.1
+ * Contact: info@mixpeek.com
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+import type { StageDefsLLMProvider } from './stage-defs-llmprovider';
+/**
+ * Configuration for delegating filtering decisions to an LLM.  **Stage Category**: FILTER  **Transformation**: N documents → ≤N documents (subset, same schema)  **Purpose**: Produces a subset of input documents using LLM-based reasoning. Use this when filtering criteria are too complex for simple attribute conditions and require semantic understanding, content analysis, or subjective judgment. Output documents have identical schema to input.  **When to Use**:     - After initial FILTER stages for intelligent content filtering     - When filtering criteria involve content understanding (sentiment, topic relevance)     - For subjective filtering (quality, appropriateness, brand alignment)     - When simple attribute filters aren\'t sufficient (complex policies, nuanced rules)     - To filter multimodal content (images, videos) based on visual criteria     - For dynamic filtering based on natural language criteria  **When NOT to Use**:     - For simple metadata filtering (use attribute_filter - much faster and cheaper)     - For reordering results (use SORT stages)     - For enriching documents (use APPLY stages)     - For aggregating documents (use REDUCE stages)     - When fast response time is critical (LLM calls are slow, 100ms-2s per batch)     - When cost is a major concern (LLM inference costs per document)  **Operational Behavior**:     - Operates on in-memory document results (no database queries)     - Produces subset of documents (removes those not meeting LLM criteria)     - Slow operation (LLM API calls, network latency)     - Processes documents in batches to optimize LLM calls     - Makes HTTP requests to Engine service for LLM inference     - Supports concurrent batching for throughput     - Output schema = Input schema (no schema changes)  **Common Pipeline Position**: FILTER (attribute_filter) → FILTER (this stage) → SORT  **Cost & Performance**:     - Expensive: LLM API costs per document evaluated     - Slow: 100ms-2s per batch depending on LLM and batch size     - Use batch_size to balance throughput vs latency     - Consider filtering with attribute_filter first to reduce LLM calls  Requirements:     - provider: OPTIONAL, LLM provider (openai, google, anthropic). Auto-inferred if not specified.     - model_name: OPTIONAL, specific model name. Uses provider default if not specified.     - criteria: OPTIONAL, natural language filtering description (defaults to empty string)       * If criteria is empty/null, stage is SKIPPED (all documents pass through)       * This saves 100ms-30s when no filtering is needed     - batch_size: OPTIONAL, defaults to 10 documents per batch     - max_concurrency: OPTIONAL, defaults to 5 concurrent requests  Use Cases:     - Content quality filtering: \"Keep only well-written, professional articles\"     - Sentiment filtering: \"Discard negative or controversial content\"     - Topic relevance: \"Keep only documents about enterprise SaaS\"     - Visual filtering: \"Keep only images with people smiling\"     - Policy compliance: \"Filter out any content mentioning competitors\"
+ * @export
+ * @interface StageParamsLlmFilter
+ */
+export interface StageParamsLlmFilter {
+    /**
+     * LLM provider to use. Supported providers: - openai: GPT models (GPT-4o, GPT-4o-mini) - google: Gemini models (Gemini 2.0 Flash) - anthropic: Claude models (Claude 3.5 Sonnet/Haiku)  If not specified, defaults to \'google\'. Can be auto-inferred from model_name.
+     * @type {StageDefsLLMProvider}
+     * @memberof StageParamsLlmFilter
+     */
+    'provider'?: StageDefsLLMProvider;
+    /**
+     * Specific LLM model to use. If not specified, uses provider default. Faster models recommended for filtering (gemini-2.0-flash, gpt-4o-mini).
+     * @type {string}
+     * @memberof StageParamsLlmFilter
+     */
+    'model_name'?: string;
+    /**
+     * DEPRECATED: Use \'provider\' and \'model_name\' instead. Legacy format: \'provider:model\' (e.g., \'gemini:gemini-2.0-flash\'). Kept for backward compatibility only.
+     * @type {string}
+     * @memberof StageParamsLlmFilter
+     * @deprecated
+     */
+    'inference_name'?: string;
+    /**
+     * Natural language description of filtering criteria. The LLM will evaluate each document against this criteria. Be specific and clear about what to keep vs discard. If empty or null, the stage is skipped (all documents pass through). Supports template variables: - {INPUT.field}: From pipeline inputs - {DOC.field}: From current document Template expressions are evaluated per-document for dynamic filtering. Examples: \'Keep only...\', \'Discard if...\', \'Filter out...\'
+     * @type {string}
+     * @memberof StageParamsLlmFilter
+     */
+    'criteria'?: string;
+    /**
+     * Whether to include LLM reasoning strings in stage metadata.
+     * @type {boolean}
+     * @memberof StageParamsLlmFilter
+     */
+    'include_reasoning'?: boolean;
+    /**
+     * OPTIONAL. Bring Your Own Key (BYOK) - use your own LLM API key instead of Mixpeek\'s.  **How to use:** 1. Store your API key as an organization secret via POST /v1/organizations/secrets    Example: {\"secret_name\": \"openai_api_key\", \"secret_value\": \"sk-proj-...\"}  2. Reference it here using template syntax: {{secrets.openai_api_key}}  **Benefits:** - Use your own API credits and rate limits - Keep your API keys secure in Mixpeek\'s encrypted vault - No changes needed to your retriever when rotating keys  If not provided, uses Mixpeek\'s default API keys (usage charged to your account).
+     * @type {string}
+     * @memberof StageParamsLlmFilter
+     */
+    'api_key'?: string;
+}
+//# sourceMappingURL=stage-params-llm-filter.d.ts.map

package/dist/models/stage-params-llm-filter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stage-params-llm-filter.d.ts","sourceRoot":"","sources":["../../models/stage-params-llm-filter.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AAKH,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAErE;;;;GAIG;AACH,MAAM,WAAW,oBAAoB;IACjC;;;;OAIG;IACH,UAAU,CAAC,EAAE,oBAAoB,CAAC;IAClC;;;;OAIG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;;;OAKG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;;OAIG;IACH,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B;;;;OAIG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;CACtB"}

package/dist/models/stage-params-mmr.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Mixpeek API
+ * This is the Mixpeek API, providing access to various endpoints for data processing and retrieval.
+ *
+ * The version of the OpenAPI document: 0.81.1
+ * Contact: info@mixpeek.com
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+import type { StageDefsDiversityFeatureConfig } from './stage-defs-diversity-feature-config';
+/**
+ * Configuration for MMR (Maximal Marginal Relevance) result diversification.  **Stage Category**: SORT  **Transformation**: N documents → N documents (reordered for diversity)  **Purpose**: Reorders search results to balance relevance with diversity, preventing result sets dominated by near-duplicate or highly similar content. Particularly valuable for multimodal search where visual/semantic similarity can lead to repetitive results.  **When to Use**:     - After feature_search when results may contain near-duplicates     - When users expect variety in search results     - For recommendation systems needing diverse suggestions     - When different facets of a query should be represented  **When NOT to Use**:     - When exact relevance ranking is critical (use sort_relevance)     - For small result sets (<5 documents) where diversity matters less     - When duplicates have already been removed via group_by  **Three Diversity Modes** (mutually exclusive):  | Mode | Config Field | Description | |------|--------------|-------------| | Single Feature | `diversity_feature_uri` | Diversity in one embedding space | | Multi-Feature | `diversity_features` | Weighted fusion across spaces | | Attribute-Based | `diversity_fields` | Diversify by metadata values |  **Mode Selection Logic**:     1. If `diversity_feature_uri` is set → Single Feature mode     2. If `diversity_features` is set → Multi-Feature mode     3. If `diversity_fields` is set → Attribute-Based mode     4. If none set → Auto-detect from previous feature_search stage  **Common Pipeline Position**: feature_search → mmr → (optional rerank)  Examples:     Single feature diversity (simplest):         ```json         {             \"lambda_\": 0.7,             \"top_k\": 25,             \"diversity_feature_uri\": \"mixpeek://clip@v1/image_embedding\"         }         ```      Multi-feature diversity (multimodal):         ```json         {             \"lambda_\": 0.6,             \"top_k\": 20,             \"diversity_features\": [                 {\"feature_uri\": \"mixpeek://text@v1/embedding\", \"weight\": 0.5},                 {\"feature_uri\": \"mixpeek://clip@v1/embedding\", \"weight\": 0.5}             ]         }         ```      Attribute-based diversity (no embeddings):         ```json         {             \"lambda_\": 0.5,             \"top_k\": 30,             \"diversity_fields\": [\"metadata.category\", \"metadata.source\"]         }         ```
+ * @export
+ * @interface StageParamsMmr
+ */
+export interface StageParamsMmr {
+    /**
+     * OPTIONAL. Balance between relevance and diversity (default: 0.7). Higher values favor relevance, lower values favor diversity.   Guidelines: - 1.0: Pure relevance (no diversity, equivalent to no MMR) - 0.7-0.8: Slight diversity while maintaining relevance (recommended) - 0.5: Balanced relevance and diversity - 0.3-0.4: High diversity, may sacrifice some relevance - 0.0: Maximum diversity (ignores relevance scores)
+     * @type {number}
+     * @memberof StageParamsMmr
+     */
+    'lambda'?: number;
+    /**
+     * OPTIONAL. Number of documents to return after MMR reordering (default: 25). MMR processes all input documents but returns only top_k. Set to match your UI\'s result count for optimal diversity.
+     * @type {number}
+     * @memberof StageParamsMmr
+     */
+    'top_k'?: number;
+    /**
+     * OPTIONAL. Single embedding feature URI for diversity computation. Use this for simple cases where one embedding space captures similarity.   If not specified and no other mode is set, auto-detects from the previous feature_search stage\'s feature_uri.   Format: \'mixpeek://extractor@version/output\'
+     * @type {string}
+     * @memberof StageParamsMmr
+     */
+    'diversity_feature_uri'?: string;
+    /**
+     * OPTIONAL. Multiple embedding features for weighted diversity fusion. Use this for multimodal content where similarity should consider multiple embedding spaces (e.g., text + image + audio).   Diversity scores from each feature are combined using weights. Weights are normalized to sum to 1.0.
+     * @type {Array<StageDefsDiversityFeatureConfig>}
+     * @memberof StageParamsMmr
+     */
+    'diversity_features'?: Array<StageDefsDiversityFeatureConfig>;
+    /**
+     * OPTIONAL. Metadata fields to use for attribute-based diversity. No embeddings required - uses field value matching.   Documents with the same field values are considered similar. Useful for categorical diversity (one per category, source, type).   Dot notation supported for nested fields.
+     * @type {Array<string>}
+     * @memberof StageParamsMmr
+     */
+    'diversity_fields'?: Array<string>;
+    /**
+     * OPTIONAL. Weights for each diversity field (for attribute-based mode). If not specified, all fields are weighted equally. Keys must match field paths in diversity_fields.
+     * @type {{ [key: string]: number; }}
+     * @memberof StageParamsMmr
+     */
+    'diversity_field_weights'?: {
+        [key: string]: number;
+    };
+    /**
+     * OPTIONAL. Document field containing relevance score from previous stage. Used as the \'relevance\' component in MMR formula.
+     * @type {string}
+     * @memberof StageParamsMmr
+     */
+    'score_field'?: string;
+    /**
+     * OPTIONAL. Field path to store the computed MMR score. Useful for debugging and understanding ranking decisions.
+     * @type {string}
+     * @memberof StageParamsMmr
+     */
+    'mmr_score_field'?: string;
+    /**
+     * OPTIONAL. Similarity metric for embedding comparison. Cosine is recommended for normalized embeddings (most common).
+     * @type {string}
+     * @memberof StageParamsMmr
+     */
+    'similarity_metric'?: StageParamsMmrSimilarityMetricEnum;
+}
+export declare const StageParamsMmrSimilarityMetricEnum: {
+    readonly Cosine: "cosine";
+    readonly Dot: "dot";
+    readonly Euclidean: "euclidean";
+};
+export type StageParamsMmrSimilarityMetricEnum = typeof StageParamsMmrSimilarityMetricEnum[keyof typeof StageParamsMmrSimilarityMetricEnum];
+//# sourceMappingURL=stage-params-mmr.d.ts.map

package/dist/models/stage-params-mmr.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stage-params-mmr.d.ts","sourceRoot":"","sources":["../../models/stage-params-mmr.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AAKH,OAAO,KAAK,EAAE,+BAA+B,EAAE,MAAM,uCAAuC,CAAC;AAE7F;;;;GAIG;AACH,MAAM,WAAW,cAAc;IAC3B;;;;OAIG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;;;;OAIG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;;OAIG;IACH,uBAAuB,CAAC,EAAE,MAAM,CAAC;IACjC;;;;OAIG;IACH,oBAAoB,CAAC,EAAE,KAAK,CAAC,+BAA+B,CAAC,CAAC;IAC9D;;;;OAIG;IACH,kBAAkB,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IACnC;;;;OAIG;IACH,yBAAyB,CAAC,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAC;KAAE,CAAC;IACvD;;;;OAIG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB;;;;OAIG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B;;;;OAIG;IACH,mBAAmB,CAAC,EAAE,kCAAkC,CAAC;CAC5D;AAED,eAAO,MAAM,kCAAkC;;;;CAIrC,CAAC;AAEX,MAAM,MAAM,kCAAkC,GAAG,OAAO,kCAAkC,CAAC,MAAM,OAAO,kCAAkC,CAAC,CAAC"}

package/dist/models/stage-params-query-expand.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Mixpeek API
+ * This is the Mixpeek API, providing access to various endpoints for data processing and retrieval.
+ *
+ * The version of the OpenAPI document: 0.81.1
+ * Contact: info@mixpeek.com
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+/**
+ * Parameters for query expansion stage.  This stage: 1. Takes your original query 2. Uses an LLM to generate semantically similar query variations 3. Executes feature_search for each variation (original + expansions) 4. Fuses results using Reciprocal Rank Fusion (RRF)  Example - Basic query expansion (copy and run):     ```python     {         \"stages\": [             {                 \"stage\": \"query_expand\",                 \"parameters\": {                     \"num_expansions\": 3,                     \"feature_search_config\": {                         \"query\": {\"text\": \"{{INPUT.query}}\"},                         \"feature_extractors\": [                             {\"field_name\": \"content.text\", \"embedding_model\": \"text\"}                         ],                         \"top_k\": 10                     }                 }             }         ]     }     ```  Example - With custom expansion prompt:     ```python     {         \"stages\": [             {                 \"stage\": \"query_expand\",                 \"parameters\": {                     \"num_expansions\": 5,                     \"expansion_prompt\": \"Generate {{NUM_EXPANSIONS}} alternative search queries for: {{QUERY}}. Focus on synonyms and related concepts. Return one query per line.\",                     \"feature_search_config\": {                         \"query\": {\"text\": \"{{INPUT.query}}\"},                         \"feature_extractors\": [                             {\"field_name\": \"content.text\", \"embedding_model\": \"text\"}                         ],                         \"top_k\": 20                     },                     \"rrf_k\": 60                 }             }         ]     }  Example - Multimodal query expansion:     ```python     {         \"stages\": [             {                 \"stage\": \"query_expand\",                 \"parameters\": {                     \"num_expansions\": 3,                     \"feature_search_config\": {                         \"query\": {\"text\": \"{{INPUT.query}}\", \"image\": \"{{INPUT.image_url}}\"},                         \"feature_extractors\": [                             {\"field_name\": \"content.text\", \"embedding_model\": \"text\"},                             {\"field_name\": \"content.image\", \"embedding_model\": \"multimodal\"}                         ],                         \"top_k\": 15                     },                     \"include_original\": true                 }             }         ]     }  How it works:     1. The original query (from feature_search_config.query.text) is sent to an LLM     2. LLM generates `num_expansions` alternative queries     3. feature_search runs for original query + each expansion     4. Results are fused using RRF: score = sum(1 / (k + rank)) across all queries     5. Documents appearing in multiple result sets get boosted  Why use query expansion:     - Handles vocabulary mismatch (user says \"car\", docs say \"vehicle\")     - Captures related concepts the user might not have thought of     - Improves recall without sacrificing precision (RRF handles fusion)     - Works with any feature_search configuration (text, image, multimodal)
+ * @export
+ * @interface StageParamsQueryExpand
+ */
+export interface StageParamsQueryExpand {
+    /**
+     * Number of query variations to generate. More expansions = better recall but slower.
+     * @type {number}
+     * @memberof StageParamsQueryExpand
+     */
+    'num_expansions'?: number;
+    /**
+     * Custom prompt for query expansion. Use {{QUERY}} for the original query and {{NUM_EXPANSIONS}} for the count. If not provided, uses a default prompt.
+     * @type {string}
+     * @memberof StageParamsQueryExpand
+     */
+    'expansion_prompt'?: string;
+    /**
+     * LLM model to use for generating query expansions.
+     * @type {string}
+     * @memberof StageParamsQueryExpand
+     */
+    'expansion_model'?: string;
+    /**
+     * Full feature_search configuration. This is the same config you would pass to a standalone feature_search stage. The query.text field will be replaced with each expanded query.
+     * @type {{ [key: string]: any; }}
+     * @memberof StageParamsQueryExpand
+     */
+    'feature_search_config': {
+        [key: string]: any;
+    };
+    /**
+     * Whether to include the original query in addition to expansions.
+     * @type {boolean}
+     * @memberof StageParamsQueryExpand
+     */
+    'include_original'?: boolean;
+    /**
+     * RRF constant k. Higher values give more weight to lower-ranked results. Default of 60 is standard. Use lower (20-40) for precision, higher (80-100) for recall.
+     * @type {number}
+     * @memberof StageParamsQueryExpand
+     */
+    'rrf_k'?: number;
+    /**
+     * How to fuse results from multiple queries. \'rrf\' = Reciprocal Rank Fusion (recommended), \'linear\' = simple score averaging.
+     * @type {string}
+     * @memberof StageParamsQueryExpand
+     */
+    'fusion_strategy'?: StageParamsQueryExpandFusionStrategyEnum;
+    /**
+     * Whether to deduplicate results by document_id before returning.
+     * @type {boolean}
+     * @memberof StageParamsQueryExpand
+     */
+    'deduplicate'?: boolean;
+}
+export declare const StageParamsQueryExpandFusionStrategyEnum: {
+    readonly Rrf: "rrf";
+    readonly Linear: "linear";
+};
+export type StageParamsQueryExpandFusionStrategyEnum = typeof StageParamsQueryExpandFusionStrategyEnum[keyof typeof StageParamsQueryExpandFusionStrategyEnum];
+//# sourceMappingURL=stage-params-query-expand.d.ts.map

package/dist/models/stage-params-query-expand.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stage-params-query-expand.d.ts","sourceRoot":"","sources":["../../models/stage-params-query-expand.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AAIH;;;;GAIG;AACH,MAAM,WAAW,sBAAsB;IACnC;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B;;;;OAIG;IACH,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B;;;;OAIG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B;;;;OAIG;IACH,uBAAuB,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;KAAE,CAAC;IACjD;;;;OAIG;IACH,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B;;;;OAIG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;;OAIG;IACH,iBAAiB,CAAC,EAAE,wCAAwC,CAAC;IAC7D;;;;OAIG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED,eAAO,MAAM,wCAAwC;;;CAG3C,CAAC;AAEX,MAAM,MAAM,wCAAwC,GAAG,OAAO,wCAAwC,CAAC,MAAM,OAAO,wCAAwC,CAAC,CAAC"}

package/dist/models/stage-params-rag-prepare.d.ts

@@ -0,0 +1,97 @@
+/**
+ * Mixpeek API
+ * This is the Mixpeek API, providing access to various endpoints for data processing and retrieval.
+ *
+ * The version of the OpenAPI document: 0.81.1
+ * Contact: info@mixpeek.com
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+import type { StageDefsCitationConfig } from './stage-defs-citation-config';
+/**
+ * Configuration for RAG context preparation.  **Stage Category**: APPLY  **Transformation**: N documents → 1 context document (single_context mode)                    OR N documents → N formatted documents (formatted_list mode)  **Purpose**: Prepare search results for LLM consumption by formatting documents, managing token budgets, and adding citations. This is a preparation stage that does NOT call an LLM - it prepares content for downstream LLM stages.  **When to Use**:     - Before passing search results to an LLM for RAG     - When you need to fit multiple documents into a token budget     - When you need citation tracking for source attribution     - When you need consistent document formatting  **When NOT to Use**:     - When you want the LLM to generate a summary (use summarize stage)     - When you don\'t need token management     - For simple pass-through of documents  **Output Modes**:     - `single_context`: Combines all documents into one context string     - `formatted_list`: Returns individually formatted documents  **Common Pipeline Position**: feature_search → rerank → rag_prepare → (external LLM call)  Examples:     Basic context preparation:         ```json         {             \"max_tokens\": 8000,             \"output_mode\": \"single_context\"         }         ```      Custom document formatting with citations:         ```json         {             \"max_tokens\": 4000,             \"document_template\": \"[{{CONTEXT.INDEX}}] {{DOC.metadata.title}}\\n{{DOC.content}}\\n\",             \"citation\": {\"style\": \"numbered\", \"include_title\": true}         }         ```      Formatted list for custom processing:         ```json         {             \"output_mode\": \"formatted_list\",             \"document_template\": \"Source: {{DOC.metadata.source}}\\n{{DOC.content}}\"         }         ```
+ * @export
+ * @interface StageParamsRagPrepare
+ */
+export interface StageParamsRagPrepare {
+    /**
+     * OPTIONAL. Maximum tokens for the combined context output. Documents exceeding this limit are handled by truncation_strategy. Default: 8000 (safe for most models).
+     * @type {number}
+     * @memberof StageParamsRagPrepare
+     */
+    'max_tokens'?: number;
+    /**
+     * OPTIONAL. Tokenizer to use for token counting. Default: \'cl100k_base\' (GPT-4/GPT-3.5 tokenizer). Options: \'cl100k_base\', \'p50k_base\', \'r50k_base\', \'gpt2\'
+     * @type {string}
+     * @memberof StageParamsRagPrepare
+     */
+    'tokenizer'?: string;
+    /**
+     * OPTIONAL. How to handle documents exceeding max_tokens: - \'priority_truncate\': Include docs in score order, truncate last to fit - \'proportional\': Give each doc proportional token budget based on count - \'drop_last\': Include complete docs until limit, drop remaining
+     * @type {string}
+     * @memberof StageParamsRagPrepare
+     */
+    'truncation_strategy'?: StageParamsRagPrepareTruncationStrategyEnum;
+    /**
+     * OPTIONAL. Output format: - \'single_context\': One document with combined \'context\' string + \'citations\' - \'formatted_list\': N documents with \'formatted_content\' field each
+     * @type {string}
+     * @memberof StageParamsRagPrepare
+     */
+    'output_mode'?: StageParamsRagPrepareOutputModeEnum;
+    /**
+     * OPTIONAL. Template for formatting each document. Available placeholders: - {{CONTEXT.INDEX}}: 1-based position in result set (1, 2, 3...) - {{CONTEXT.CITATION}}: Citation marker based on citation.style - {{DOC.*}}: Any document field (e.g., {{DOC.content}}, {{DOC.metadata.title}})
+     * @type {string}
+     * @memberof StageParamsRagPrepare
+     */
+    'document_template'?: string;
+    /**
+     * Primary field to extract content from each document.
+     * @type {string}
+     * @memberof StageParamsRagPrepare
+     */
+    'content_field'?: string;
+    /**
+     * Separator between documents in single_context mode.
+     * @type {string}
+     * @memberof StageParamsRagPrepare
+     */
+    'separator'?: string;
+    /**
+     * Citation configuration for source tracking.
+     * @type {StageDefsCitationConfig}
+     * @memberof StageParamsRagPrepare
+     */
+    'citation'?: StageDefsCitationConfig;
+    /**
+     * Field name for combined context (single_context mode).
+     * @type {string}
+     * @memberof StageParamsRagPrepare
+     */
+    'context_field'?: string;
+    /**
+     * Field name for citation metadata.
+     * @type {string}
+     * @memberof StageParamsRagPrepare
+     */
+    'citations_field'?: string;
+    /**
+     * Field name for formatted content (formatted_list mode).
+     * @type {string}
+     * @memberof StageParamsRagPrepare
+     */
+    'formatted_content_field'?: string;
+}
+export declare const StageParamsRagPrepareTruncationStrategyEnum: {
+    readonly PriorityTruncate: "priority_truncate";
+    readonly Proportional: "proportional";
+    readonly DropLast: "drop_last";
+};
+export type StageParamsRagPrepareTruncationStrategyEnum = typeof StageParamsRagPrepareTruncationStrategyEnum[keyof typeof StageParamsRagPrepareTruncationStrategyEnum];
+export declare const StageParamsRagPrepareOutputModeEnum: {
+    readonly SingleContext: "single_context";
+    readonly FormattedList: "formatted_list";
+};
+export type StageParamsRagPrepareOutputModeEnum = typeof StageParamsRagPrepareOutputModeEnum[keyof typeof StageParamsRagPrepareOutputModeEnum];
+//# sourceMappingURL=stage-params-rag-prepare.d.ts.map

package/dist/models/stage-params-rag-prepare.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stage-params-rag-prepare.d.ts","sourceRoot":"","sources":["../../models/stage-params-rag-prepare.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AAKH,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,8BAA8B,CAAC;AAE5E;;;;GAIG;AACH,MAAM,WAAW,qBAAqB;IAClC;;;;OAIG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;;OAIG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;;OAIG;IACH,qBAAqB,CAAC,EAAE,2CAA2C,CAAC;IACpE;;;;OAIG;IACH,aAAa,CAAC,EAAE,mCAAmC,CAAC;IACpD;;;;OAIG;IACH,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B;;;;OAIG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB;;;;OAIG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;;OAIG;IACH,UAAU,CAAC,EAAE,uBAAuB,CAAC;IACrC;;;;OAIG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB;;;;OAIG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B;;;;OAIG;IACH,yBAAyB,CAAC,EAAE,MAAM,CAAC;CACtC;AAED,eAAO,MAAM,2CAA2C;;;;CAI9C,CAAC;AAEX,MAAM,MAAM,2CAA2C,GAAG,OAAO,2CAA2C,CAAC,MAAM,OAAO,2CAA2C,CAAC,CAAC;AACvK,eAAO,MAAM,mCAAmC;;;CAGtC,CAAC;AAEX,MAAM,MAAM,mCAAmC,GAAG,OAAO,mCAAmC,CAAC,MAAM,OAAO,mCAAmC,CAAC,CAAC"}

package/dist/models/stage-params-rerank.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Mixpeek API
+ * This is the Mixpeek API, providing access to various endpoints for data processing and retrieval.
+ *
+ * The version of the OpenAPI document: 0.81.1
+ * Contact: info@mixpeek.com
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+/**
+ * Configuration for reranking documents using cross-encoder models.  Reranking refines search results by computing query-document relevance scores using cross-encoder models (e.g., BGE reranker). More accurate than vector similarity but slower, so typically used on top-K results.  Common Pipeline:     feature_filter (retrieve 100) → rerank (refine to 10) → sort_relevance
+ * @export
+ * @interface StageParamsRerank
+ */
+export interface StageParamsRerank {
+    /**
+     * Reranking inference service name. Must be a reranking service. Use GET /engine/inference to list available rerankers.
+     * @type {string}
+     * @memberof StageParamsRerank
+     */
+    'inference_name'?: string;
+    /**
+     * Query text to compare against documents. Supports template variables: {{INPUT.query}}, etc.
+     * @type {string}
+     * @memberof StageParamsRerank
+     */
+    'query'?: string;
+    /**
+     * Document field path containing text to rerank against
+     * @type {string}
+     * @memberof StageParamsRerank
+     */
+    'document_field'?: string;
+    /**
+     * Number of top documents to keep after reranking. If None, returns all documents in reranked order.
+     * @type {number}
+     * @memberof StageParamsRerank
+     */
+    'top_k'?: number;
+    /**
+     * Document field path to store reranking scores
+     * @type {string}
+     * @memberof StageParamsRerank
+     */
+    'score_field'?: string;
+    /**
+     * Batch size for reranking inference calls
+     * @type {number}
+     * @memberof StageParamsRerank
+     */
+    'batch_size'?: number;
+    /**
+     * Maximum characters of document text to send for reranking. The cross-encoder tokenizer truncates to ~512 tokens anyway, so sending full page content (often 10K+ chars) wastes bandwidth and increases latency. 2000 chars ≈ 500 tokens covers the tokenizer window with margin.
+     * @type {number}
+     * @memberof StageParamsRerank
+     */
+    'max_document_chars'?: number;
+    /**
+     * Maximum number of inference batches to process concurrently. When the number of pairs exceeds batch_size, they are split into batches and sent as concurrent inference requests.
+     * @type {number}
+     * @memberof StageParamsRerank
+     */
+    'max_concurrent_batches'?: number;
+}
+//# sourceMappingURL=stage-params-rerank.d.ts.map

package/dist/models/stage-params-rerank.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stage-params-rerank.d.ts","sourceRoot":"","sources":["../../models/stage-params-rerank.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AAIH;;;;GAIG;AACH,MAAM,WAAW,iBAAiB;IAC9B;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B;;;;OAIG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B;;;;OAIG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;;OAIG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB;;;;OAIG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;;OAIG;IACH,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B;;;;OAIG;IACH,wBAAwB,CAAC,EAAE,MAAM,CAAC;CACrC"}

package/dist/models/stage-params-sample.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Mixpeek API
+ * This is the Mixpeek API, providing access to various endpoints for data processing and retrieval.
+ *
+ * The version of the OpenAPI document: 0.81.1
+ * Contact: info@mixpeek.com
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+/**
+ * Configuration for document sampling.  **Stage Category**: REDUCE  **Transformation**: N documents → M documents (where M ≤ N)  **Purpose**: Sample a subset of documents using random or stratified sampling. Operates on in-memory results from previous stages.  **When to Use**:     - A/B testing different pipeline configurations     - Reducing result set for expensive downstream stages     - Exploration and discovery features     - Ensuring proportional representation across categories     - Creating reproducible experiments with seeded sampling  **When NOT to Use**:     - When you need all results (just use previous stage output)     - For ranking/reordering (use SORT stages)     - For filtering by criteria (use FILTER stages)  **Sampling Strategies**:     - `random`: Uniform random sampling     - `stratified`: Proportional sampling across a field\'s values     - `reservoir`: Reservoir sampling (for streaming scenarios)  **Common Pipeline Position**: feature_search → (expensive stages) → sample  Examples:     Basic random sampling:         ```json         {             \"count\": 10,             \"strategy\": \"random\"         }         ```      Stratified sampling by category:         ```json         {             \"count\": 20,             \"strategy\": \"stratified\",             \"stratify_by\": \"metadata.category\"         }         ```      Reproducible sampling with seed:         ```json         {             \"count\": 50,             \"strategy\": \"random\",             \"seed\": 42         }         ```      Preserve top results, sample rest:         ```json         {             \"count\": 10,             \"strategy\": \"random\",             \"preserve_top_k\": 3         }         ```
+ * @export
+ * @interface StageParamsSample
+ */
+export interface StageParamsSample {
+    /**
+     * REQUIRED. Number of documents to sample. If count > available documents, returns all documents.
+     * @type {number}
+     * @memberof StageParamsSample
+     */
+    'count'?: number;
+    /**
+     * OPTIONAL. Sampling strategy: - \'random\': Uniform random sampling (default) - \'stratified\': Proportional sampling across stratify_by field values - \'reservoir\': Reservoir sampling (memory-efficient for large sets)
+     * @type {string}
+     * @memberof StageParamsSample
+     */
+    'strategy'?: StageParamsSampleStrategyEnum;
+    /**
+     * OPTIONAL. Field to stratify on (required when strategy=\'stratified\'). Samples proportionally from each unique value of this field. Supports dot notation for nested fields.
+     * @type {string}
+     * @memberof StageParamsSample
+     */
+    'stratify_by'?: string;
+    /**
+     * OPTIONAL. Minimum documents per stratum (stratified mode). Ensures each category gets at least this many documents.
+     * @type {number}
+     * @memberof StageParamsSample
+     */
+    'min_per_stratum'?: number;
+    /**
+     * OPTIONAL. Random seed for reproducible sampling. Same seed + same input = same output. Leave None for non-deterministic sampling.
+     * @type {number}
+     * @memberof StageParamsSample
+     */
+    'seed'?: number;
+    /**
+     * OPTIONAL. Always keep the top K documents by score, sample from remainder. Useful when you want to guarantee top results are included. Default: 0 (no preservation, sample from all).
+     * @type {number}
+     * @memberof StageParamsSample
+     */
+    'preserve_top_k'?: number;
+}
+export declare const StageParamsSampleStrategyEnum: {
+    readonly Random: "random";
+    readonly Stratified: "stratified";
+    readonly Reservoir: "reservoir";
+};
+export type StageParamsSampleStrategyEnum = typeof StageParamsSampleStrategyEnum[keyof typeof StageParamsSampleStrategyEnum];
+//# sourceMappingURL=stage-params-sample.d.ts.map