Model Profiles Management

Overview

Model Profiles manage associations between model configurations and model endpoints within the View platform. They provide centralized configuration for linking specific AI model settings with endpoint connections, enabling organized model management and streamlined AI model deployment across different environments.

Model Profiles are managed via the View server API and provide comprehensive associations between model configurations and endpoints, including profile naming, metadata, and active status management for optimal AI model organization and deployment.

Model Profile Object Structure

Model Profile objects contain comprehensive associations between model configurations and endpoints. Here's the complete structure:

{
  "GUID": "00000000-0000-0000-0000-000000000000",
  "TenantGUID": "00000000-0000-0000-0000-000000000000",
  "ModelConfigurationGUID": "00000000-0000-0000-0000-000000000000",
  "ModelEndpointGUID": "00000000-0000-0000-0000-000000000000",
  "Name": "Model profile for Ollama and all-minilm",
  "AdditionalData": "Description for Ollama and all-minilm",
  "Active": true,
  "CreatedUtc": "2025-10-08T19:39:59.160283Z"
}

Field Descriptions

GUID (GUID): Globally unique identifier for the model profile object
TenantGUID (GUID): Globally unique identifier for the tenant
ModelConfigurationGUID (GUID): Globally unique identifier for the associated model configuration
ModelEndpointGUID (GUID): Globally unique identifier for the associated model endpoint
Name (string): Display name for the model profile
AdditionalData (string): Additional metadata or description for the profile
Active (boolean): Whether the profile is currently active and available
CreatedUtc (datetime): Timestamp when the profile was created

Enumerate Model Profiles

Retrieves all model profiles for a tenant using GET /v2.0/tenants/[tenant-guid]/modelprofiles. Returns a JSON array containing all model profile associations.

Request Parameters

No additional parameters required beyond authentication.

Response

Returns an array of all model profiles for the tenant, or a 404 Not Found error if no profiles exist.

curl --location 'http://localhost:8000/v2.0/tenants/00000000-0000-0000-0000-000000000000/modelprofiles/' \
--header 'Authorization: ••••••'

import { ViewSdk } from "view-sdk";
const api = new ViewSdk(
  "[endpoint-url]", //endpoint
  "[tenant-guid]", //tenant Id
  "[access-key]" //access key
);
const enumerateModelProfiles = async () => {
  try {
    const response = await api.ModelProfile.enumerate();
    console.log(response, 'Model profiles fetched successfully');
  } catch (err) {
    console.log('Error fetching Model profiles:', err);
  }
};
enumerateModelProfiles();

import view_sdk
from view_sdk import configuration
from view_sdk.sdk_configuration import Service

sdk = view_sdk.configure(
    access_key="default",
    base_url="endpoint-url",
    tenant_guid="tenant-guid",
    service_ports={Service.DEFAULT: 8000},
)

def enumerateModelProfiles():
    """Enumerate all model profiles."""
    model_profiles = configuration.ModelProfile.enumerate()
    print("Enumerated ModelProfiles:")
    print(model_profiles)

enumerateModelProfiles()

Response

Returns an array of all model profiles:

{
    "Success": true,
    "Timestamp": {
        "Start": "2025-10-09T09:26:18.001794Z",
        "TotalMs": 10.27,
        "Messages": {}
    },
    "MaxResults": 1000,
    "Skip": 0,
    "IterationsRequired": 1,
    "EndOfResults": true,
    "TotalRecords": 2,
    "RecordsRemaining": 0,
    "Objects": [
        {
            "GUID": "00000000-0000-0000-0000-000000000000",
            "TenantGUID": "00000000-0000-0000-0000-000000000000",
            "ModelConfigurationGUID": "00000000-0000-0000-0000-000000000000",
            "ModelEndpointGUID": "00000000-0000-0000-0000-000000000000",
            "Name": "Model profile for Ollama and all-minilm",
            "AdditionalData": "Description for Ollama and all-minilm",
            "Active": true,
            "CreatedUtc": "2025-10-08T19:39:59.160283Z"
        },
        {
            "GUID": "00000000-0000-0000-0000-000000000001",
            "TenantGUID": "00000000-0000-0000-0000-000000000000",
            "ModelConfigurationGUID": "00000000-0000-0000-0000-000000000001",
            "ModelEndpointGUID": "00000000-0000-0000-0000-000000000000",
            "Name": "Model profile for Ollama and qwen2.5:3b",
            "AdditionalData": "Description for Ollama and qwen2.5:3b",
            "Active": true,
            "CreatedUtc": "2025-10-08T19:39:59.160283Z"
        }
    ]
}

Read All Model Profiles

Retrieves all model profiles for a tenant using GET /v1.0/tenants/[tenant-guid]/modelprofiles. Returns a JSON array containing all model profile associations with complete details.

Response

Returns an array of all model profiles for the tenant, or a 404 Not Found error if no profiles exist.

curl --location 'http://localhost:8000/v1.0/tenants/[tenant-guid]/modelprofiles' \
--header 'Authorization: [access-key]'

import { ViewSdk } from "view-sdk";

const api = new ViewSdk(
  "[endpoint-url]", //endpoint
  "[tenant-guid]", //tenant Id
  "[access-key]" //access key
);
const readAllModelProfiles = async () => {
  try {
    const response = await api.ModelProfile.readAll();
    console.log(response, 'All model profiles fetched successfully');
  } catch (err) {
    console.log('Error fetching All model profiles:', err);
  }
};
readAllModelProfiles();

import view_sdk
from view_sdk import configuration
from view_sdk.sdk_configuration import Service

sdk = view_sdk.configure(
    access_key="default",
    base_url="endpoint-url",
    tenant_guid="tenant-guid",
    service_ports={Service.DEFAULT: 8000},
)

def retrieveAllModelProfiles():
    """Retrieve all model profiles."""
    model_profiles = configuration.ModelProfile.retrieve_all()
    print("All ModelProfiles:")
    print(model_profiles)

retrieveAllModelProfiles()

Response

Returns an array of all model profiles with complete details:

[
  {
    "GUID": "00000000-0000-0000-0000-000000000000",
    "TenantGUID": "00000000-0000-0000-0000-000000000000",
    "ModelConfigurationGUID": "00000000-0000-0000-0000-000000000000",
    "ModelEndpointGUID": "00000000-0000-0000-0000-000000000000",
    "Name": "Model profile for Ollama and all-minilm",
    "AdditionalData": "Description for Ollama and all-minilm",
    "Active": true,
    "CreatedUtc": "2025-10-08T19:39:59.160283Z"
  },
  {
    "GUID": "11111111-1111-1111-1111-111111111111",
    "TenantGUID": "00000000-0000-0000-0000-000000000000",
    "ModelConfigurationGUID": "11111111-1111-1111-1111-111111111111",
    "ModelEndpointGUID": "11111111-1111-1111-1111-111111111111",
    "Name": "GPT-4 Profile with OpenAI Endpoint",
    "AdditionalData": "Production GPT-4 configuration with OpenAI API",
    "Active": true,
    "CreatedUtc": "2025-10-08T20:15:30.123456Z"
  }
]

Read Model Profile

Retrieves a specific model profile by GUID using GET /v1.0/tenants/[tenant-guid]/modelprofiles/[modelprofile-guid]. Returns the complete profile association with all details.

Request Parameters

modelprofile-guid (string, Path, Required): GUID of the model profile to retrieve

Response

Returns the model profile object with all association details if found, or a 404 Not Found error if the profile doesn't exist.

Note: The HEAD method can be used as an alternative to simply check the existence of the object. HEAD requests return either a 200 OK if the object exists, or a 404 Not Found if not. No response body is returned with a HEAD request.

curl --location 'http://localhost:8000/v1.0/tenants/[tenant-guid]/modelprofiles/[modelprofile-guid]' \
--header 'Authorization: [access-key]'

import { ViewSdk } from "view-sdk";

const api = new ViewSdk(
  "[endpoint-url]", //endpoint
  "[tenant-guid]", //tenant Id
  "[access-key]" //access key
);

const readModelProfile = async () => {
  try {
    const response = await api.ModelProfile.read('00000000-0000-0000-0000-000000000000');
    console.log(response, 'Model profile fetched successfully');
  } catch (err) {
    console.log('Error fetching Model profile:', err);
  }
};

readModelProfile();

import view_sdk
from view_sdk import configuration
from view_sdk.sdk_configuration import Service

sdk = view_sdk.configure(
    access_key="default",
    base_url="endpoint-url",
    tenant_guid="tenant-guid",
    service_ports={Service.DEFAULT: 8000},
)

def readModelProfile():
    """Retrieve a specific model profile by GUID."""
    model_profile = configuration.ModelProfile.retrieve(
        "modelprofile-guid"
    )
    print("Retrieved ModelProfile:")
    print(model_profile)

readModelProfile()

Response

Returns the complete model profile with association details:

{
  "GUID": "00000000-0000-0000-0000-000000000000",
  "TenantGUID": "00000000-0000-0000-0000-000000000000",
  "ModelConfigurationGUID": "00000000-0000-0000-0000-000000000000",
  "ModelEndpointGUID": "00000000-0000-0000-0000-000000000000",
  "Name": "Model profile for Ollama and all-minilm",
  "AdditionalData": "Description for Ollama and all-minilm",
  "Active": true,
  "CreatedUtc": "2025-10-08T19:39:59.160283Z"
}

Create Model Profile

Creates a new model profile using PUT /v1.0/tenants/[tenant-guid]/modelprofiles. Creates a new profile association with the specified parameters.

Request Parameters

ModelConfigurationGUID (GUID, Required): GUID of the model configuration to associate
ModelEndpointGUID (GUID, Required): GUID of the model endpoint to associate
Name (string, Required): Display name for the model profile
AdditionalData (string, Optional): Additional metadata or description
Active (boolean, Optional): Whether the profile is active (default: true)

Request Body

{
  "ModelConfigurationGUID": "22222222-2222-2222-2222-222222222222",
  "ModelEndpointGUID": "33333333-3333-3333-3333-333333333333",
  "Name": "Llama 2 Profile with Local Endpoint",
  "AdditionalData": "Local Llama 2 configuration with Ollama endpoint",
  "Active": true
}

Response

Returns the created model profile object with all association details, or a 400 Bad Request error if the request is invalid.

curl --location --request PUT 'http://localhost:8000/v1.0/tenants/00000000-0000-0000-0000-000000000000/modelprofiles' \
--header 'content-type: application/json' \
--header 'Authorization: ••••••' \
--data '{
    "ModelConfigurationGUID": "00000000-0000-0000-0000-000000000000",
    "ModelEndpointGUID": "00000000-0000-0000-0000-000000000000",
    "Name": "My model profile",
    "AdditionalData": "My open text field",
    "Active": true
}'

import { ViewSdk } from "view-sdk";

const api = new ViewSdk(
  "[endpoint-url]", //endpoint
  "[tenant-guid]", //tenant Id
  "[access-key]" //access key
);

const createModelProfile = async () => {
  try {
    const response = await api.ModelProfile.create({
      ModelConfigurationGUID: '00000000-0000-0000-0000-000000000000',
      ModelEndpointGUID: '00000000-0000-0000-0000-000000000000',
      Name: 'Model profile for Ollama and all-minilm',
      AdditionalData: 'Description for Ollama and all-minilm',
      Active: true,
    });
    console.log(response, 'Model profile created successfully');
  } catch (err) {
    console.log('Error creating Model profile:', err);
  }
};

createModelProfile();

import view_sdk
from view_sdk import configuration
from view_sdk.sdk_configuration import Service

sdk = view_sdk.configure(
    access_key="default",
    base_url="endpoint-url",
    tenant_guid="tenant-guid",
    service_ports={Service.DEFAULT: 8000},
)

def createModelProfile():
    """Create a new model profile."""
    model_profile = configuration.ModelProfile.create(
        ModelConfigurationGUID="modelconfig-guid",
        ModelEndpointGUID="modelendpoint-guid",
        Name="Demo Model Profile",
        AdditionalData="Demo model profile for testing",
        Active=True
    )
    print("Created ModelProfile:")
    print(model_profile)
    return model_profile

createModelProfile()

Response

Returns the created model profile with complete association details:

 {
   "GUID": "00000000-0000-0000-0000-000000000001",
   "TenantGUID": "00000000-0000-0000-0000-000000000000",
   "ModelConfigurationGUID": "00000000-0000-0000-0000-000000000001",
   "ModelEndpointGUID": "00000000-0000-0000-0000-000000000000",
   "Name": "Model profile for Ollama and qwen2.5:3b",
   "AdditionalData": "Description for Ollama and qwen2.5:3b",
   "Active": true,
   "CreatedUtc": "2025-10-08T19:39:59.160283Z"
 }

Update Model Profile

Updates an existing model profile using PUT /v1.0/tenants/[tenant-guid]/modelprofiles/[modelprofile-guid]. Modifies the profile association with the provided parameters.

Request Parameters

modelprofile-guid (string, Path, Required): GUID of the model profile to update

Request Body

{
    "ModelConfigurationGUID": "00000000-0000-0000-0000-000000000000",
    "ModelEndpointGUID": "00000000-0000-0000-0000-000000000000",
    "Name": "My model profile",
    "AdditionalData": "My open text field",
    "Active": true
}

Response

Returns the updated model profile object with all association details, or a 404 Not Found error if the profile doesn't exist.

curl --location --request PUT 'http://localhost:8000/v1.0/tenants/00000000-0000-0000-0000-000000000000/modelprofiles/00000000-0000-0000-0000-000000000000' \
--header 'content-type: application/json' \
--header 'Authorization: ••••••' \
--data '{
    "ModelConfigurationGUID": "00000000-0000-0000-0000-000000000000",
    "ModelEndpointGUID": "00000000-0000-0000-0000-000000000000",
    "Name": "My model profile",
    "AdditionalData": "My open text field",
    "Active": true
}'

import { ViewSdk } from "view-sdk";

const api = new ViewSdk(
  "[endpoint-url]", //endpoint
  "[tenant-guid]", //tenant Id
  "[access-key]" //access key
);

const updateModelProfile = async () => {
  try {
    const response = await api.ModelProfile.update({
      GUID: '1edeedff-67b3-43de-b8a2-f636de2620bc',
      TenantGUID: '00000000-0000-0000-0000-000000000000',
      ModelConfigurationGUID: '00000000-0000-0000-0000-000000000000',
      ModelEndpointGUID: '00000000-0000-0000-0000-000000000000',
      Name: 'Model profile for Ollama and all-minilm [UPDATED]',
      AdditionalData: 'Updated description for Ollama and all-minilm',
      Active: true,
      CreatedUtc: '2025-10-08T19:39:59.160283Z',
    });
    console.log(response, 'Model profile updated successfully');
  } catch (err) {
    console.log('Error updating Model profile:', err);
  }
};

updateModelProfile();

import view_sdk
from view_sdk import configuration
from view_sdk.sdk_configuration import Service

sdk = view_sdk.configure(
    access_key="default",
    base_url="endpoint-url",
    tenant_guid="tenant-guid",
    service_ports={Service.DEFAULT: 8000},
)

def updateModelProfile():
    """Update an existing model profile."""
    model_profile = configuration.ModelProfile.update(
        "modelprofile-guid",
        ModelConfigurationGUID="modelconfig-guid",
        Name="Demo Model Profile [Updated]",
        AdditionalData="Updated demo model profile for testing"
    )
    print("Updated ModelProfile:")
    print(model_profile)

updateModelProfile()

Response

Returns the updated model profile with complete association details:

{
  "GUID": "00000000-0000-0000-0000-000000000000",
  "TenantGUID": "00000000-0000-0000-0000-000000000000",
  "ModelConfigurationGUID": "55555555-5555-5555-5555-555555555555",
  "ModelEndpointGUID": "66666666-6666-6666-6666-666666666666",
  "Name": "Updated Llama 2 Profile",
  "AdditionalData": "Updated Llama 2 configuration with new endpoint",
  "Active": true,
  "CreatedUtc": "2025-10-08T19:39:59.160283Z"
}

Check Model Profile Existence

Checks whether a model profile exists using HEAD /v1.0/tenants/[tenant-guid]/modelprofiles/[modelprofile-guid]. Returns only HTTP status codes without response body for efficient existence verification.

Request Parameters

modelprofile-guid (string, Path, Required): GUID of the model profile to check

Response

200 OK: Model profile exists
404 Not Found: Model profile does not exist
No response body: Only HTTP status code is returned

Note: HEAD requests do not return a response body, only the HTTP status code indicating whether the model profile exists.

curl --location --head 'http://localhost:8000/v1.0/tenants/00000000-0000-0000-0000-000000000000/modelprofiles/00000000-0000-0000-0000-000000000000' \
--header 'Authorization: ••••••'

import { ViewSdk } from "view-sdk";

const api = new ViewSdk(
  "[endpoint-url]", //endpoint
  "[tenant-guid]", //tenant Id
  "[access-key]" //access key
);

const modelProfileExists = async () => {
  try {
    const response = await api.ModelProfile.exists('00000000-0000-0000-0000-000000000000');
    console.log(response, 'Model profile exists');
  } catch (err) {
    console.log('Error checking Model profile:', err);
  }
};

modelProfileExists();

import view_sdk
from view_sdk import configuration
from view_sdk.sdk_configuration import Service

sdk = view_sdk.configure(
    access_key="default",
    base_url="endpoint-url",
    tenant_guid="tenant-guid",
    service_ports={Service.DEFAULT: 8000},
)

def existsModelProfile():
    """Check if a model profile exists."""
    exists = configuration.ModelProfile.exists(
        "modelprofile-guid"
    )
    print("ModelProfile exists:")
    print(exists)

existsModelProfile()

Response

200 No Content: Model profile exists
404 Not Found: Model profile does not exist
No response body: Only HTTP status code is returned

Note: HEAD requests do not return a response body, only the HTTP status code indicating whether the model profile exists.

Delete Model Profile

Deletes a model profile by GUID using DELETE /v1.0/tenants/[tenant-guid]/modelprofiles/[modelprofile-guid]. Removes the profile association from the system.

Request Parameters

modelprofile-guid (string, Path, Required): GUID of the model profile to delete

Response

200 OK: Model profile deleted successfully
404 Not Found: Model profile does not exist

Note: Deleting a model profile removes it from the system permanently. This action cannot be undone.

curl --location --request DELETE 'http://localhost:8000/v1.0/tenants/00000000-0000-0000-0000-000000000000/modelprofiles/00000000-0000-0000-0000-000000000000' \
--header 'Authorization: ••••••'

import { ViewSdk } from "view-sdk";

const api = new ViewSdk(
  "[endpoint-url]", //endpoint
  "[tenant-guid]", //tenant Id
  "[access-key]" //access key
);

const deleteModelProfile = async () => {
  try {
    const response = await api.ModelProfile.delete('1edeedff-67b3-43de-b8a2-f636de2620bc');
    console.log(response, 'Model profile deleted successfully');
  } catch (err) {
    console.log('Error deleting Model profile:', err);
  }
};

deleteModelProfile();

import view_sdk
from view_sdk import configuration
from view_sdk.sdk_configuration import Service

sdk = view_sdk.configure(
    access_key="default",
    base_url="endpoint-url",
    tenant_guid="tenant-guid",
    service_ports={Service.DEFAULT: 8000},
)

def deleteModelProfile():
    """Delete a model profile."""
    result = configuration.ModelProfile.delete(
        "modelprofile-guid"
    )
    print("Deleted ModelProfile:")
    print(result)

deleteModelProfile()

Response

Returns 204 No Content on successful deletion. No response body is returned.

Best Practices

When managing model profiles in the View platform, consider the following recommendations for optimal AI model organization, association management, and system maintenance:

Profile Organization: Use descriptive names to clearly identify the purpose and scope of each model profile
Association Validation: Ensure that referenced model configurations and endpoints exist and are properly configured
Active Status Management: Monitor and manage active status to control which profiles are available for use
Documentation: Use AdditionalData field to document profile purposes, use cases, and deployment scenarios
Profile Lifecycle: Implement proper lifecycle management for profiles across different environments (dev, staging, production)
Association Integrity: Regularly validate that associated configurations and endpoints are still valid and accessible
Performance Monitoring: Track profile usage and performance to optimize model selection and deployment
Backup and Recovery: Maintain backup profiles for critical model deployments to ensure continuity

Next Steps

After successfully managing model profiles, you can:

Model Deployment: Use configured profiles to deploy AI models with specific configurations to designated endpoints
Environment Management: Organize profiles by environment (development, staging, production) for streamlined deployment
Configuration Management: Leverage profiles to manage different model configurations across various deployment scenarios
Performance Optimization: Monitor profile performance and adjust associations based on usage patterns and requirements
Platform Integration: Integrate model profiles with other View platform services for comprehensive AI model management