mixpeek.ManifestApi

All URIs are relative to https://api.mixpeek.com

Method	HTTP request	Description
apply_manifest	POST /v1/manifest/apply	Apply Manifest
diff_manifest	POST /v1/manifest/diff	Diff Manifest
export_manifest_get	GET /v1/manifest/export	Export Manifest Get
export_manifest_post	POST /v1/manifest/export	Export Manifest Post
generate_manifest	POST /v1/manifest/generate	Generate Manifest
lint_manifest	POST /v1/manifest/lint	Lint Manifest
validate_manifest	POST /v1/manifest/validate	Validate Manifest

apply_manifest

ApplyResult apply_manifest(manifest_file, dry_run=dry_run, authorization=authorization)

Apply Manifest

Apply a YAML manifest to create resources.

Creates all resources defined in the manifest file in dependency order. Fails if any resource already exists (create-only mode). Performs automatic rollback if any resource creation fails.

Features:

Topological sorting ensures resources are created in correct dependency order
Secret references (${{ secrets.NAME }}) are resolved from organization secrets
Atomic operation: rolls back all created resources if any creation fails
Dry run mode validates the manifest without making changes

Example:

curl -X POST /v1/manifest/apply \
  -H "Authorization: Bearer $API_KEY" \
  -H "X-Namespace-Id: ns_xxx" \
  -F "manifest_file=@mixpeek.yaml"

Example manifest:

version: "1.0"
metadata:
  name: "my-environment"

namespaces:
  - name: video_search
    feature_extractors:
      - name: multimodal_extractor
        version: v1

buckets:
  - name: raw_videos
    namespace: video_search
    schema:
      properties:
        video: { type: video }

Example

import mixpeek
from mixpeek.models.apply_result import ApplyResult
from mixpeek.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to https://api.mixpeek.com
# See configuration.py for a list of all supported configuration parameters.
configuration = mixpeek.Configuration(
    host = "https://api.mixpeek.com"
)


# Enter a context with an instance of the API client
with mixpeek.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = mixpeek.ManifestApi(api_client)
    manifest_file = None # bytearray | YAML manifest file
    dry_run = False # bool | Validate only, don't create resources (optional) (default to False)
    authorization = 'authorization_example' # str | REQUIRED: Bearer token authentication using your API key. Format: 'Bearer sk_xxxxxxxxxxxxx'. You can create API keys in the Mixpeek dashboard under Organization Settings. (optional)

    try:
        # Apply Manifest
        api_response = api_instance.apply_manifest(manifest_file, dry_run=dry_run, authorization=authorization)
        print("The response of ManifestApi->apply_manifest:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ManifestApi->apply_manifest: %s\n" % e)

Parameters

Name	Type	Description	Notes
manifest_file	bytearray	YAML manifest file
dry_run	bool	Validate only, don't create resources	[optional] [default to False]
authorization	str	REQUIRED: Bearer token authentication using your API key. Format: 'Bearer sk_xxxxxxxxxxxxx'. You can create API keys in the Mixpeek dashboard under Organization Settings.	[optional]

Return type

ApplyResult

Authorization

No authorization required

HTTP request headers

Content-Type: multipart/form-data
Accept: application/json

HTTP response details

Status code	Description	Response headers
201	Successful Response	-
400	Bad Request	-
401	Unauthorized	-
403	Forbidden	-
404	Not Found	-
422	Validation Error	-
500	Internal Server Error	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

diff_manifest

DiffResult diff_manifest(manifest_file, authorization=authorization)

Diff Manifest

Compare a manifest file with current state.

Shows resources that would be:

Created: In manifest but not in system
In system only: In system but not in manifest
Different: In both but with configuration differences

This is useful for understanding what changes would occur before applying a manifest.

Example:

curl -X POST /v1/manifest/diff \
  -H "Authorization: Bearer $API_KEY" \
  -F "manifest_file=@mixpeek.yaml"

Example

import mixpeek
from mixpeek.models.diff_result import DiffResult
from mixpeek.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to https://api.mixpeek.com
# See configuration.py for a list of all supported configuration parameters.
configuration = mixpeek.Configuration(
    host = "https://api.mixpeek.com"
)


# Enter a context with an instance of the API client
with mixpeek.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = mixpeek.ManifestApi(api_client)
    manifest_file = None # bytearray | YAML manifest file
    authorization = 'authorization_example' # str | REQUIRED: Bearer token authentication using your API key. Format: 'Bearer sk_xxxxxxxxxxxxx'. You can create API keys in the Mixpeek dashboard under Organization Settings. (optional)

    try:
        # Diff Manifest
        api_response = api_instance.diff_manifest(manifest_file, authorization=authorization)
        print("The response of ManifestApi->diff_manifest:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ManifestApi->diff_manifest: %s\n" % e)

Parameters

Name	Type	Description	Notes
manifest_file	bytearray	YAML manifest file
authorization	str	REQUIRED: Bearer token authentication using your API key. Format: 'Bearer sk_xxxxxxxxxxxxx'. You can create API keys in the Mixpeek dashboard under Organization Settings.	[optional]

Return type

DiffResult

Authorization

No authorization required

HTTP request headers

Content-Type: multipart/form-data
Accept: application/json

HTTP response details

Status code	Description	Response headers
200	Successful Response	-
400	Bad Request	-
401	Unauthorized	-
403	Forbidden	-
404	Not Found	-
422	Validation Error	-
500	Internal Server Error	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

export_manifest_get

object export_manifest_get(namespace_id=namespace_id, format=format, manifest_name=manifest_name, authorization=authorization)

Export Manifest Get

Export current resources to a YAML manifest.

Exports all resources (or a specific namespace) to a YAML file that can be version-controlled and re-applied to another environment.

Features:

Resource IDs are converted to human-readable names
Secret values are replaced with placeholder references (${{ secrets.NAME }})
Output is formatted for readability and git-friendliness

Note: You must configure actual secrets before applying the exported manifest to a new environment.

Example:

# Export all resources
curl /v1/manifest/export \
  -H "Authorization: Bearer $API_KEY" \
  -o mixpeek.yaml

# Export specific namespace
curl "/v1/manifest/export?namespace_id=ns_abc123" \
  -H "Authorization: Bearer $API_KEY" \
  -o namespace.yaml

Example

import mixpeek
from mixpeek.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to https://api.mixpeek.com
# See configuration.py for a list of all supported configuration parameters.
configuration = mixpeek.Configuration(
    host = "https://api.mixpeek.com"
)


# Enter a context with an instance of the API client
with mixpeek.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = mixpeek.ManifestApi(api_client)
    namespace_id = 'namespace_id_example' # str | Export specific namespace (None = all) (optional)
    format = 'yaml' # str | Output format (yaml) (optional) (default to 'yaml')
    manifest_name = 'exported-manifest' # str | Name for the manifest (optional) (default to 'exported-manifest')
    authorization = 'authorization_example' # str | REQUIRED: Bearer token authentication using your API key. Format: 'Bearer sk_xxxxxxxxxxxxx'. You can create API keys in the Mixpeek dashboard under Organization Settings. (optional)

    try:
        # Export Manifest Get
        api_response = api_instance.export_manifest_get(namespace_id=namespace_id, format=format, manifest_name=manifest_name, authorization=authorization)
        print("The response of ManifestApi->export_manifest_get:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ManifestApi->export_manifest_get: %s\n" % e)

Parameters

Name	Type	Description	Notes
namespace_id	str	Export specific namespace (None = all)	[optional]
format	str	Output format (yaml)	[optional] [default to 'yaml']
manifest_name	str	Name for the manifest	[optional] [default to 'exported-manifest']
authorization	str	REQUIRED: Bearer token authentication using your API key. Format: 'Bearer sk_xxxxxxxxxxxxx'. You can create API keys in the Mixpeek dashboard under Organization Settings.	[optional]

Return type

object

Authorization

No authorization required

HTTP request headers

Content-Type: Not defined
Accept: application/json

HTTP response details

Status code	Description	Response headers
200	Successful Response	-
400	Bad Request	-
401	Unauthorized	-
403	Forbidden	-
404	Not Found	-
422	Validation Error	-
500	Internal Server Error	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

export_manifest_post

object export_manifest_post(manifest_name=manifest_name, authorization=authorization, request_body=request_body)

Export Manifest Post

Export current resources to a YAML manifest (POST version for agent tools).

Same as GET /export but accepts parameters in JSON body instead of query params. Used by agent tools and programmatic API clients.

Example:

curl -X POST /v1/manifest/export \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"namespace_ids": ["ns_abc123"], "manifest_name": "my-setup"}'

Example

import mixpeek
from mixpeek.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to https://api.mixpeek.com
# See configuration.py for a list of all supported configuration parameters.
configuration = mixpeek.Configuration(
    host = "https://api.mixpeek.com"
)


# Enter a context with an instance of the API client
with mixpeek.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = mixpeek.ManifestApi(api_client)
    manifest_name = 'exported-manifest' # str |  (optional) (default to 'exported-manifest')
    authorization = 'authorization_example' # str | REQUIRED: Bearer token authentication using your API key. Format: 'Bearer sk_xxxxxxxxxxxxx'. You can create API keys in the Mixpeek dashboard under Organization Settings. (optional)
    request_body = ['request_body_example'] # List[str] |  (optional)

    try:
        # Export Manifest Post
        api_response = api_instance.export_manifest_post(manifest_name=manifest_name, authorization=authorization, request_body=request_body)
        print("The response of ManifestApi->export_manifest_post:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ManifestApi->export_manifest_post: %s\n" % e)

Parameters

Name	Type	Description	Notes
manifest_name	str		[optional] [default to 'exported-manifest']
authorization	str	REQUIRED: Bearer token authentication using your API key. Format: 'Bearer sk_xxxxxxxxxxxxx'. You can create API keys in the Mixpeek dashboard under Organization Settings.	[optional]
request_body	List[str]		[optional]

Return type

object

Authorization

No authorization required

HTTP request headers

Content-Type: application/json
Accept: application/json

HTTP response details

Status code	Description	Response headers
200	Successful Response	-
400	Bad Request	-
401	Unauthorized	-
403	Forbidden	-
404	Not Found	-
422	Validation Error	-
500	Internal Server Error	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

generate_manifest

object generate_manifest(description, manifest_name=manifest_name, authorization=authorization)

Generate Manifest

Generate a manifest from natural language description.

Uses AI to create a valid YAML manifest from a natural language description
of desired resources. The generated manifest can be reviewed and applied.

**Example:**
```bash
curl -X POST /v1/manifest/generate \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "description": "I need a bucket of images that feeds into a multimodal extractor and a retriever",
    "manifest_name": "image-search-setup"
  }'
```

**Response:**
```json
{
  "manifest": "version: '1.0'

metadata: name: image-search-setup ...", "format": "yaml", "manifest_name": "image-search-setup", "description": "I need a bucket of images..." } ```

**Next Steps:**
1. Review the generated manifest
2. Apply it using POST /v1/manifest/apply

Example

import mixpeek
from mixpeek.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to https://api.mixpeek.com
# See configuration.py for a list of all supported configuration parameters.
configuration = mixpeek.Configuration(
    host = "https://api.mixpeek.com"
)


# Enter a context with an instance of the API client
with mixpeek.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = mixpeek.ManifestApi(api_client)
    description = 'description_example' # str | 
    manifest_name = 'generated-manifest' # str |  (optional) (default to 'generated-manifest')
    authorization = 'authorization_example' # str | REQUIRED: Bearer token authentication using your API key. Format: 'Bearer sk_xxxxxxxxxxxxx'. You can create API keys in the Mixpeek dashboard under Organization Settings. (optional)

    try:
        # Generate Manifest
        api_response = api_instance.generate_manifest(description, manifest_name=manifest_name, authorization=authorization)
        print("The response of ManifestApi->generate_manifest:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ManifestApi->generate_manifest: %s\n" % e)

Parameters

Name	Type	Description	Notes
description	str
manifest_name	str		[optional] [default to 'generated-manifest']
authorization	str	REQUIRED: Bearer token authentication using your API key. Format: 'Bearer sk_xxxxxxxxxxxxx'. You can create API keys in the Mixpeek dashboard under Organization Settings.	[optional]

Return type

object

Authorization

No authorization required

HTTP request headers

Content-Type: Not defined
Accept: application/json

HTTP response details

Status code	Description	Response headers
200	Successful Response	-
400	Bad Request	-
401	Unauthorized	-
403	Forbidden	-
404	Not Found	-
422	Validation Error	-
500	Internal Server Error	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

lint_manifest

LintResponse lint_manifest(manifest_file, skip_rules=skip_rules, authorization=authorization)

Lint Manifest

Lint a YAML manifest for best practices and potential issues.

Goes beyond basic validation to provide actionable suggestions for improving your manifest configuration. This endpoint is designed for AI agents and developers who want to optimize their Mixpeek setup.

Lint Rules:

UNUSED_EXTRACTOR: Feature extractor defined but not used by any collection
UNUSED_COLLECTION: Collection not referenced by any retriever
MISSING_INPUT_SCHEMA: Retriever uses templates but has no input_schema
MISSING_CACHE_CONFIG: Retriever without caching (especially with LLM stages)
SUBOPTIMAL_STAGE_ORDER: Filter stages after expensive operations
DUPLICATE_FEATURE_URI: Same feature searched multiple times
MISSING_DESCRIPTION: Resources without descriptions
NO_SEARCH_STAGE: Retriever with no search stages
EXTRACTOR_NOT_IN_NAMESPACE: Collection uses extractor not in namespace
MISSING_SECRET: Secret reference not configured

Severity Levels:

error: Must be fixed before applying
warning: Best practice violation, should be fixed
info: Suggestion for improvement

Example:

curl -X POST /v1/manifest/lint \
  -H "Authorization: Bearer $API_KEY" \
  -F "manifest_file=@mixpeek.yaml"

Response includes actionable suggestions:

{
  "valid": true,
  "results": [
    {
      "code": "MISSING_CACHE_CONFIG",
      "severity": "warning",
      "message": "Retriever 'product_search' has no cache configuration",
      "location": "retrievers[0]",
      "suggestion": "Add cache_config to improve performance",
      "fix_example": "cache_config:\n  enabled: true\n  ttl_seconds: 3600"
    }
  ],
  "summary": {"error": 0, "warning": 1, "info": 0}
}

Example

import mixpeek
from mixpeek.models.lint_response import LintResponse
from mixpeek.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to https://api.mixpeek.com
# See configuration.py for a list of all supported configuration parameters.
configuration = mixpeek.Configuration(
    host = "https://api.mixpeek.com"
)


# Enter a context with an instance of the API client
with mixpeek.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = mixpeek.ManifestApi(api_client)
    manifest_file = None # bytearray | YAML manifest file
    skip_rules = [] # List[str] | Rule codes to skip (e.g., MISSING_DESCRIPTION) (optional) (default to [])
    authorization = 'authorization_example' # str | REQUIRED: Bearer token authentication using your API key. Format: 'Bearer sk_xxxxxxxxxxxxx'. You can create API keys in the Mixpeek dashboard under Organization Settings. (optional)

    try:
        # Lint Manifest
        api_response = api_instance.lint_manifest(manifest_file, skip_rules=skip_rules, authorization=authorization)
        print("The response of ManifestApi->lint_manifest:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ManifestApi->lint_manifest: %s\n" % e)

Parameters

Name	Type	Description	Notes
manifest_file	bytearray	YAML manifest file
skip_rules	List[str]	Rule codes to skip (e.g., MISSING_DESCRIPTION)	[optional] [default to []]
authorization	str	REQUIRED: Bearer token authentication using your API key. Format: 'Bearer sk_xxxxxxxxxxxxx'. You can create API keys in the Mixpeek dashboard under Organization Settings.	[optional]

Return type

LintResponse

Authorization

No authorization required

HTTP request headers

Content-Type: multipart/form-data
Accept: application/json

HTTP response details

Status code	Description	Response headers
200	Successful Response	-
400	Bad Request	-
401	Unauthorized	-
403	Forbidden	-
404	Not Found	-
422	Validation Error	-
500	Internal Server Error	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

validate_manifest

ValidateResult validate_manifest(manifest_file, authorization=authorization)

Validate Manifest

Validate a YAML manifest without applying.

Checks:

YAML syntax validity
Schema validation against manifest models
Cross-resource reference validation
Dependency resolution (no circular dependencies)
Secret reference existence

Returns detailed validation results including:

Resource counts by type
Missing secrets that need to be configured
Validation errors and warnings

Example:

curl -X POST /v1/manifest/validate \
  -H "Authorization: Bearer $API_KEY" \
  -F "manifest_file=@mixpeek.yaml"

Example

import mixpeek
from mixpeek.models.validate_result import ValidateResult
from mixpeek.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to https://api.mixpeek.com
# See configuration.py for a list of all supported configuration parameters.
configuration = mixpeek.Configuration(
    host = "https://api.mixpeek.com"
)


# Enter a context with an instance of the API client
with mixpeek.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = mixpeek.ManifestApi(api_client)
    manifest_file = None # bytearray | YAML manifest file
    authorization = 'authorization_example' # str | REQUIRED: Bearer token authentication using your API key. Format: 'Bearer sk_xxxxxxxxxxxxx'. You can create API keys in the Mixpeek dashboard under Organization Settings. (optional)

    try:
        # Validate Manifest
        api_response = api_instance.validate_manifest(manifest_file, authorization=authorization)
        print("The response of ManifestApi->validate_manifest:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ManifestApi->validate_manifest: %s\n" % e)

Parameters

Name	Type	Description	Notes
manifest_file	bytearray	YAML manifest file
authorization	str	REQUIRED: Bearer token authentication using your API key. Format: 'Bearer sk_xxxxxxxxxxxxx'. You can create API keys in the Mixpeek dashboard under Organization Settings.	[optional]

Return type

ValidateResult

Authorization

No authorization required

HTTP request headers

Content-Type: multipart/form-data
Accept: application/json

HTTP response details

Status code	Description	Response headers
200	Successful Response	-
400	Bad Request	-
401	Unauthorized	-
403	Forbidden	-
404	Not Found	-
422	Validation Error	-
500	Internal Server Error	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

FilesExpand file tree

ManifestApi.md

Latest commit

History

ManifestApi.md

File metadata and controls

mixpeek.ManifestApi

apply_manifest

Example

Parameters

Return type

Authorization

HTTP request headers

HTTP response details

diff_manifest

Example

Parameters

Return type

Authorization

HTTP request headers

HTTP response details

export_manifest_get

Example

Parameters

Return type

Authorization

HTTP request headers

HTTP response details

export_manifest_post

Example

Parameters

Return type

Authorization

HTTP request headers

HTTP response details

generate_manifest

Example

Parameters

Return type

Authorization

HTTP request headers

HTTP response details

lint_manifest

Example

Parameters

Return type

Authorization

HTTP request headers

HTTP response details

validate_manifest

Example

Parameters

Return type

Authorization

HTTP request headers

HTTP response details