Overview

The View Embeddings Rules management system provides comprehensive configuration for AI-powered text processing workflows. Embeddings rules define how text content is processed, chunked, tokenized, and converted into vector embeddings for storage and retrieval within the View platform.

Key Features

AI-Powered Processing: Configure advanced text processing using HuggingFace models and LCProxy generators
Intelligent Chunking: Define content chunking strategies with configurable size limits and processing parameters
Vector Generation: Set up automated vector embedding generation with batch processing and retry logic
Multi-Repository Storage: Store processed data in both graph and vector repositories
Content Type Filtering: Apply rules based on specific content types or use wildcards for broad matching
Scalable Processing: Configure parallel processing with configurable task limits and batch sizes
Error Handling: Built-in retry mechanisms and failure tolerance for robust processing

Supported Operations

Create: Define new embeddings processing rules with comprehensive configuration
Read: Retrieve embeddings rule configurations and metadata
Enumerate: List all embeddings rules with pagination support
Update: Modify existing embeddings rule configurations
Delete: Remove embeddings rules from the system
Existence Check: Verify embeddings rule presence without retrieving details

API Endpoints

Embeddings rules are managed via the Configuration server API at [http|https]://[hostname]:[port]/v1.0/tenants/[tenant-guid]/embeddingsrules

Supported HTTP Methods: GET, HEAD, PUT, DELETE

Embeddings Rule Object Structure

Embeddings rule objects contain comprehensive configuration for AI-powered text processing workflows. Here's the complete structure:

{
    "GUID": "embeddings-rule",
    "TenantGUID": "default",
    "BucketGUID": "example-data-bucket",
    "OwnerGUID": "default",
    "Name": "My embeddings rule",
    "ContentType": "*",
    "GraphRepositoryGUID": "example-graph-repository",
    "VectorRepositoryGUID": "example-vector-repository",
    "ProcessingEndpoint": "http://nginx-processor:8000/v1.0/tenants/00000000-0000-0000-0000-000000000000/processing",
    "ProcessingAccessKey": "***ault",
    "ChunkingServerUrl": "http://nginx-chunker:8000/v1.0/tenants/00000000-0000-0000-0000-000000000000/chunking",
    "ChunkingServerApiKey": "***ault",
    "MaxChunkingTasks": 16,
    "MinChunkContentLength": 1,
    "MaxChunkContentLength": 1,
    "MaxTokensPerChunk": 1,
    "TokenOverlap": 32,
    "TokenizationModel": "sentence-transformers/all-MiniLM-L6-v2",
    "HuggingFaceApiKey": "***ault",
    "EmbeddingsServerUrl": "http://nginx-embeddings:8000/",
    "EmbeddingsServerApiKey": "***ault",
    "EmbeddingsGenerator": "LCProxy",
    "EmbeddingsGeneratorUrl": "http://nginx-lcproxy:8000/",
    "EmbeddingsGeneratorApiKey": "***ault",
    "EmbeddingsBatchSize": 16,
    "MaxEmbeddingsTasks": 16,
    "MaxEmbeddingsRetries": 3,
    "MaxEmbeddingsFailures": 3,
    "VectorStoreUrl": "http://nginx-vector:8311/",
    "VectorStoreAccessKey": "***ault",
    "MaxContentLength": 16777216,
    "CreatedUtc": "2024-07-10T05:09:32.000000Z"
}

Field Descriptions

GUID (GUID): Globally unique identifier for the embeddings rule object
TenantGUID (GUID): Globally unique identifier for the tenant
BucketGUID (GUID): GUID of the source bucket containing data to process
OwnerGUID (GUID): GUID of the user who owns this embeddings rule
Name (string): Display name of the embeddings rule
ContentType (string): Content type filter (use "*" for all types)
CreatedUtc (datetime): UTC timestamp when the rule was created
GraphRepositoryGUID (GUID): GUID of the graph repository for storing processed data
VectorRepositoryGUID (GUID): GUID of the vector repository for storing embeddings
ProcessingEndpoint (string): URL of the data processing endpoint
ProcessingAccessKey (string): Access key for the processing endpoint
ChunkingServerUrl (string): URL of the text chunking server
ChunkingServerApiKey (string): Access key for the chunking server
MaxChunkingTasks (integer): Maximum number of parallel chunking tasks
MinChunkContentLength (integer): Minimum length for content chunks
MaxChunkContentLength (integer): Maximum length for content chunks
MaxTokensPerChunk (integer): Maximum tokens per chunk for processing
TokenOverlap (integer): Number of overlapping tokens between consecutive chunks
TokenizationModel (string): HuggingFace model for text tokenization
HuggingFaceApiKey (string): API key for HuggingFace model access
EmbeddingsServerUrl (string): URL of the embeddings generation server
EmbeddingsServerApiKey (string): Access key for the embeddings server
EmbeddingsGenerator (enum): Generator type (currently only "LCProxy")
EmbeddingsGeneratorUrl (string): URL of the embeddings generator service
EmbeddingsGeneratorApiKey (string): API key for the embeddings generator
EmbeddingsBatchSize (integer): Number of chunks to process per batch
MaxEmbeddingsTasks (integer): Maximum parallel embeddings generation tasks
MaxTokensPerChunk (integer): Maximum tokens per chunk for processing
MaxEmbeddingsRetries (integer): Maximum retry attempts for failed batches
MaxEmbeddingsFailures (integer): Maximum failures before job termination
VectorStoreUrl (string): URL of the vector storage server
VectorStoreAccessKey (string): Access key for vector storage
MaxContentLength (integer): Maximum content length to process (in bytes)

Create Embeddings Rule

Creates a new embeddings rule with comprehensive AI processing configuration using PUT /v1.0/tenants/[tenant-guid]/embeddingsrules. This endpoint allows you to define complete text processing workflows including chunking, tokenization, and vector generation.

Request Parameters

Required Parameters

BucketGUID (string, Body, Required): GUID of the source bucket containing data to process
OwnerGUID (string, Body, Required): GUID of the user who owns this embeddings rule
Name (string, Body, Required): Display name for the embeddings rule
ContentType (string, Body, Required): Content type filter (use "*" for all types)
GraphRepositoryGUID (string, Body, Required): GUID of the graph repository for storing processed data
VectorRepositoryGUID (string, Body, Required): GUID of the vector repository for storing embeddings
EmbeddingsGenerator (string, Body, Required): Generator type (currently only "LCProxy")

Processing Configuration

ProcessingEndpoint (string, Body, Required): URL of the data processing endpoint
ProcessingAccessKey (string, Body, Required): Access key for the processing endpoint

Chunking Configuration

ChunkingServerUrl (string, Body, Optional): URL of the text chunking server
ChunkingServerApiKey (string, Body, Optional): Access key for the chunking server
MaxChunkingTasks (integer, Body, Optional): Maximum number of parallel chunking tasks
MinChunkContentLength (integer, Body, Optional): Minimum length for content chunks
MaxChunkContentLength (integer, Body, Optional): Maximum length for content chunks

AI Model Configuration

TokenizationModel (string, Body, Optional): HuggingFace model for text tokenization
HuggingFaceApiKey (string, Body, Optional): API key for HuggingFace model access

Embeddings Generation

EmbeddingsGeneratorUrl (string, Body, Required): URL of the embeddings generator service
EmbeddingsGeneratorApiKey (string, Body, Optional): API key for the embeddings generator
EmbeddingsBatchSize (integer, Body, Optional): Number of chunks to process per batch
MaxEmbeddingsTasks (integer, Body, Optional): Maximum parallel embeddings generation tasks
MaxTokensPerChunk (integer, Body, Optional): Maximum tokens per chunk for processing
MaxEmbeddingsRetries (integer, Body, Optional): Maximum retry attempts for failed batches
MaxEmbeddingsFailures (integer, Body, Optional): Maximum failures before job termination

Vector Storage

VectorStoreUrl (string, Body, Required): URL of the vector storage server
VectorStoreAccessKey (string, Body, Required): Access key for vector storage
MaxContentLength (integer, Body, Optional): Maximum content length to process (in bytes)

curl --location --request PUT 'http://localhost:8000/v1.0/tenants/00000000-0000-0000-0000-000000000000/embeddingsrules' \
--header 'content-type: application/json' \
--header 'Authorization: ••••••' \
--data '{
    "BucketGUID": "00000000-0000-0000-0000-000000000000",
    "Name": "Embeddings rule",
    "ContentType": "*",
    "GraphRepositoryGUID": "00000000-0000-0000-0000-000000000000",
    "VectorRepositoryGUID": "00000000-0000-0000-0000-000000000000",
    "ProcessingEndpoint": "http://localhost:8000/v1.0/tenants/00000000-0000-0000-0000-000000000000/processing",
    "ProcessingAccessKey": "default",
    "EmbeddingsGenerator": "LCProxy",
    "EmbeddingsGeneratorUrl": "http://localhost:8000/v1.0/tenants/00000000-0000-0000-0000-000000000000/embeddings",
   "TokenizationModel": "sentence-transformers/all-MiniLM-L6-v2",
    "HuggingFaceApiKey" : "default",
    "EmbeddingsGeneratorApiKey": "default",
    "EmbeddingsBatchSize": 512,
    "MaxGeneratorTasks": 32,
    "MaxEmbeddingsRetries": 3,
    "MaxEmbeddingsFailures": 3,
    "VectorStoreUrl": "http://localhost:8000/",
    "VectorStoreAccessKey": "default",
    "MaxContentLength": 16777216
}'

import { ViewConfigurationSdk } from "view-sdk";

const api = new ViewConfigurationSdk(
  "http://localhost:8000/", //endpoint
  "default", //tenant Id
  "default" //access key
);

const createEmbeddingRules = async () => {
  try {
    const response = await api.EmbeddingRule.create({
      BucketGUID: "<bucket-guid>",
      Name: "Embeddings rule test ash",
      ContentType: "*",
      GraphRepositoryGUID: "<graph-repository-guid>",
      VectorRepositoryGUID: "<vector-repository-guid>",
      ProcessingEndpoint:
        "http://localhost:8000/v1.0/tenants/00000000-0000-0000-0000-000000000000/processing",
      ProcessingAccessKey: "default",
      EmbeddingsGenerator: "LCProxy",
      EmbeddingsGeneratorUrl:
        "http://localhost:8000/v1.0/tenants/00000000-0000-0000-0000-000000000000/embeddings",
      EmbeddingsGeneratorApiKey: "",
      BatchSize: 512,
      MaxGeneratorTasks: 32,
      MaxRetries: 3,
      MaxFailures: 3,
      VectorStoreUrl: "http://localhost:8000/",
      VectorStoreAccessKey: "default",
      MaxContentLength: 16777216,
    });
    console.log(response, "Embedding rule created successfully");
  } catch (err) {
    console.log("Error creating Embedding rule:", err);
  }
};

createEmbeddingRules();

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

sdk = view_sdk.configure(
    access_key="default",
    base_url="localhost", 
    tenant_guid="default"
)

def createEmbeddingRules():
    embeddingRules = configuration.EmbeddingsRule.create(
        BucketGUID="00000000-0000-0000-0000-000000000000",
        Name="Embeddings rule",
        ContentType="*",
        GraphRepositoryGUID="00000000-0000-0000-0000-000000000000",
        VectorRepositoryGUID="00000000-0000-0000-0000-000000000000",
        ProcessingEndpoint="http://localhost:8000/v1.0/tenants/00000000-0000-0000-0000-000000000000/processing",
        ProcessingAccessKey="default",
        EmbeddingsGenerator="LCProxy",
        EmbeddingsGeneratorUrl="http://localhost:8000/v1.0/tenants/00000000-0000-0000-0000-000000000000/embeddings",
        EmbeddingsGeneratorApiKey="",
        EmbeddingsBatchSize=512,
        MaxEmbeddingsTasks=32,
        MaxEmbeddingsRetries=3,
        MaxEmbeddingsFailures=3,
        VectorStoreUrl="http://localhost:8000/",
        VectorStoreAccessKey="default",
        MaxContentLength=16777216,
    )
    print(embeddingRules)


createEmbeddingRules()

using View.Sdk;
using View.Sdk.Configuration;

ViewConfigurationSdk sdk = new ViewConfigurationSdk(Guid.Parse("<tenant-guid>"),"default", "http://localhost:8000/");
            
EmbeddingsRule request = new EmbeddingsRule
{
   BucketGUID = Guid.Parse("<bucket-guid>"),
   Name = "Embeddings rule test ash",
   ContentType = "*",
   GraphRepositoryGUID = Guid.Parse("<graph-repository-guid>"),
   VectorRepositoryGUID = Guid.Parse("<vector-repository-guid>"),
   ProcessingEndpoint = "http://localhost:8000/v1.0/tenants/00000000-0000-0000-0000-000000000000/processing",
   ProcessingAccessKey = "default",
   EmbeddingsGenerator = EmbeddingsGeneratorEnum.LCProxy,
   EmbeddingsGeneratorUrl = "http://localhost:8000/v1.0/tenants/00000000-0000-0000-0000-000000000000/embeddings",
   EmbeddingsGeneratorApiKey = "",
   BatchSize = 512,
   MaxGeneratorTasks = 32,
   MaxRetries = 3,
   MaxFailures = 3,
   VectorStoreUrl = "http://localhost:8000/",
   VectorStoreAccessKey = "default",
   MaxContentLength = 16777216,
};

EmbeddingsRule response = await sdk.EmbeddingsRule.Create(request);

Response

Returns the created embeddings rule object with all configuration details:

{
    "GUID": "6046481e-5682-462a-a1a2-a7e1e242b1ff",
    "TenantGUID": "00000000-0000-0000-0000-000000000000",
    "BucketGUID": "00000000-0000-0000-0000-000000000000",
    "OwnerGUID": "00000000-0000-0000-0000-000000000000",
    "Name": "Embeddings rule",
    "ContentType": "*",
    "GraphRepositoryGUID": "00000000-0000-0000-0000-000000000000",
    "VectorRepositoryGUID": "00000000-0000-0000-0000-000000000000",
    "ProcessingEndpoint": "http://localhost:8000/v1.0/tenants/00000000-0000-0000-0000-000000000000/processing",
    "ProcessingAccessKey": "***ault",
    "ChunkingServerUrl": "http://nginx-chunker:8000/v1.0/tenants/00000000-0000-0000-0000-000000000000/chunking",
    "ChunkingServerApiKey": "***ault",
    "MaxChunkingTasks": 16,
    "MinChunkContentLength": 1,
    "MaxChunkContentLength": 1,
    "MaxTokensPerChunk": 1,
    "TokenOverlap": 32,
    "TokenizationModel": "sentence-transformers/all-MiniLM-L6-v2",
    "HuggingFaceApiKey": "***ault",
    "EmbeddingsServerUrl": "http://nginx-embeddings:8000/",
    "EmbeddingsServerApiKey": "***ault",
    "EmbeddingsGenerator": "LCProxy",
    "EmbeddingsGeneratorUrl": "http://nginx-lcproxy:8000/",
    "EmbeddingsGeneratorApiKey": "***ault",
    "EmbeddingsBatchSize": 16,
    "MaxEmbeddingsTasks": 16,
    "MaxEmbeddingsRetries": 3,
    "MaxEmbeddingsFailures": 3,
    "VectorStoreUrl": "http://nginx-vector:8311/",
    "VectorStoreAccessKey": "***ault",
    "MaxContentLength": 16777216,
    "CreatedUtc": "2024-10-21T14:33:55.000000Z"
}

Enumerate Embeddings Rules

Retrieves a paginated list of all embeddings rule objects in the tenant using GET /v2.0/tenants/[tenant-guid]/embeddingsrules. This endpoint provides comprehensive enumeration with pagination support for managing multiple embeddings rules.

Response Structure

The enumeration response includes pagination metadata and embeddings rule objects:

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

import { ViewConfigurationSdk } from "view-sdk";

const api = new ViewConfigurationSdk(
  "http://localhost:8000/", //endpoint
  "default", //tenant Id
  "default" //access key
);


const enumerateEmbeddingRules = async () => {
  try {
    const response = await api.EmbeddingRule.enumerate();
    console.log(response, "Embedding rules fetched successfully");
  } catch (err) {
    console.log("Error fetching Embedding rules:", err);
  }
};

enumerateEmbeddingRules();

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

sdk = view_sdk.configure(
    access_key="default",
    base_url="localhost", 
    tenant_guid="default",
    service_ports={Service.DEFAULT: 8000},
)

def enumerateEmbeddingsRules():
    embeddingsRules = configuration.EmbeddingsRule.enumerate()
    print(embeddingsRules)

enumerateEmbeddingsRules()

using View.Sdk;
using View.Sdk.Configuration;

ViewConfigurationSdk sdk = new ViewConfigurationSdk(Guid.Parse("<tenant-guid>"),"default", "http://localhost:8000/");
            
EnumerationResult<EmbeddingsRule> response = await sdk.EmbeddingsRule.Enumerate();

Response

Returns a paginated list of embeddings rule objects:

{
    "Success": true,
    "Timestamp": {
        "Start": "2024-10-21T02:36:37.677751Z",
        "TotalMs": 23.58,
        "Messages": {}
    },
    "MaxResults": 10,
    "IterationsRequired": 1,
    "EndOfResults": true,
    "RecordsRemaining": 0,
    "Objects": [
        {
            "GUID": "6046481e-5682-462a-a1a2-a7e1e242b1ff",
            "TenantGUID": "00000000-0000-0000-0000-000000000000",
            "BucketGUID": "00000000-0000-0000-0000-000000000000",
            "OwnerGUID": "00000000-0000-0000-0000-000000000000",
    "Name": "Embeddings rule",
    "ContentType": "*",
            "GraphRepositoryGUID": "00000000-0000-0000-0000-000000000000",
            "VectorRepositoryGUID": "00000000-0000-0000-0000-000000000000",
            "ProcessingEndpoint": "http://localhost:8000/v1.0/tenants/00000000-0000-0000-0000-000000000000/processing",
            "ProcessingAccessKey": "***ault",
            "MaxTokensPerChunk": 1,
            "TokenOverlap": 32,
    "EmbeddingsGenerator": "LCProxy",
            "EmbeddingsGeneratorUrl": "http://nginx-lcproxy:8000/",
            "EmbeddingsGeneratorApiKey": "***ault",
    "EmbeddingsBatchSize": 16,
            "MaxEmbeddingsTasks": 16,
    "MaxEmbeddingsRetries": 3,
    "MaxEmbeddingsFailures": 3,
            "VectorStoreUrl": "http://nginx-vector:8311/",
            "VectorStoreAccessKey": "***ault",
    "MaxContentLength": 16777216,
            "CreatedUtc": "2024-10-21T14:33:55.000000Z"
        }
    ],
    "ContinuationToken": null
}

Read Embeddings Rule

Retrieves embeddings rule configuration by GUID using GET /v1.0/tenants/[tenant-guid]/embeddingsrule/[embeddingsrule-guid]. Returns the complete embeddings rule configuration including all processing parameters. If the rule doesn't exist, a 404 error is returned.

Request Parameters

embeddingsrule-guid (string, Path, Required): GUID of the embeddings rule object to retrieve

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


import { ViewConfigurationSdk } from "view-sdk";

const api = new ViewConfigurationSdk(
  "http://localhost:8000/", //endpoint
  "default", //tenant Id
  "default" //access key
);

const readEmbeddingRule = async () => {
  try {
    const response = await api.EmbeddingRule.read(
      "<embeddingsrule-guid>"
    );
    console.log(response, "Embedding rule fetched successfully");
  } catch (err) {
    console.log("Error fetching Embedding rule:", err);
  }
};

readEmbeddingRule();

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

sdk = view_sdk.configure(
    access_key="default",
    base_url="localhost", 
    tenant_guid="default",
    service_ports={Service.DEFAULT: 8000},
)

def readEmbeddingsRules():
    embeddingsRules = configuration.EmbeddingsRule.retrieve("<embeddingsrule-guid>")
    print(embeddingsRules)

readEmbeddingsRules()

using View.Sdk;
using View.Sdk.Configuration;

ViewConfigurationSdk sdk = new ViewConfigurationSdk(Guid.Parse("<tenant-guid>"),"default", "http://localhost:8000/");
            
EmbeddingsRule response = await sdk.EmbeddingsRule.Retrieve(Guid.Parse("<embeddingsrule-guid>"));

Response

Returns the complete embeddings rule configuration:

{
    "GUID": "59f7c18d-7342-4aef-9308-86083459dd81",
    "TenantGUID": "default",
    "BucketGUID": "example-data-bucket",
    "OwnerGUID": "default",
    "Name": "Embeddings rule",
    "ContentType": "*",
    "GraphRepositoryGUID": "example-graph-repository",
    "VectorRepositoryGUID": "example-vector-repository",
    "ProcessingEndpoint": "http://localhost:8501/processor",
    "ProcessingAccessKey": "***ault",
    "ChunkingServerUrl": "http://nginx-chunker:8000/v1.0/tenants/00000000-0000-0000-0000-000000000000/chunking",
    "ChunkingServerApiKey": "***ault",
    "MaxChunkingTasks": 16,
    "MinChunkContentLength": 1,
    "MaxChunkContentLength": 1,
    "MaxTokensPerChunk": 1,
    "TokenOverlap": 32,
    "TokenizationModel": "sentence-transformers/all-MiniLM-L6-v2",
    "HuggingFaceApiKey": "***ault",
    "EmbeddingsServerUrl": "http://nginx-embeddings:8000/",
    "EmbeddingsServerApiKey": "***ault",
    "EmbeddingsGenerator": "LCProxy",
    "EmbeddingsGeneratorUrl": "http://localhost:8301/",
    "EmbeddingsGeneratorApiKey": "***ault",
    "EmbeddingsBatchSize": 16,
    "MaxEmbeddingsTasks": 16,
    "MaxEmbeddingsRetries": 3,
    "MaxEmbeddingsFailures": 3,
    "VectorStoreUrl": "http://localhost:8311/",
    "VectorStoreAccessKey": "***ault",
    "MaxContentLength": 16777216,
    "CreatedUtc": "2024-10-21T15:19:09.000000Z"
}

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

Read All Embeddings Rules

Retrieves all embeddings rule objects in the tenant using GET /v1.0/tenants/[tenant-guid]/embeddingsrules/. Returns an array of embeddings rule objects with complete configuration details for all rules in the tenant.

Request Parameters

No additional parameters required beyond authentication.

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

import { ViewConfigurationSdk } from "view-sdk";

const api = new ViewConfigurationSdk(
  "http://localhost:8000/", //endpoint
  "default", //tenant Id
  "default" //access key
);

const readAllEmbeddingRules = async () => {
  try {
    const response = await api.EmbeddingRule.readAll();
    console.log(response, "All embedding rules fetched successfully");
  } catch (err) {
    console.log("Error fetching Embedding rules:", err);
  }
};
readAllEmbeddingRules();

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

sdk = view_sdk.configure(
    access_key="default",
    base_url="localhost", 
    tenant_guid="default",
    service_ports={Service.DEFAULT: 8000},
)

def readAllEmbeddingsRules():
    embeddingsRules = configuration.EmbeddingsRule.retrieve_all()
    print(embeddingsRules)

readAllEmbeddingsRules()

using View.Sdk;
using View.Sdk.Configuration;

ViewConfigurationSdk sdk = new ViewConfigurationSdk(Guid.Parse("<tenant-guid>"),"default", "http://localhost:8000/");
            
List<EmbeddingsRule> response = await sdk.EmbeddingsRule.RetrieveMany();

Response

Returns an array of all embeddings rule objects:

[
    {
        "GUID": "59f7c18d-7342-4aef-9308-86083459dd81",
        "TenantGUID": "default",
        "BucketGUID": "example-data-bucket",
        "OwnerGUID": "default",
        "Name": "Embeddings rule",
        "ContentType": "*",
        "GraphRepositoryGUID": "example-graph-repository",
        "VectorRepositoryGUID": "example-vector-repository",
        "ProcessingEndpoint": "http://localhost:8501/processor",
        "ProcessingAccessKey": "***ault",
        "MaxTokensPerChunk": 1,
        "TokenOverlap": 32,
        "EmbeddingsGenerator": "LCProxy",
        "EmbeddingsGeneratorUrl": "http://localhost:8301/",
        "EmbeddingsGeneratorApiKey": "***ault",
        "EmbeddingsBatchSize": 16,
        "MaxEmbeddingsTasks": 16,
        "MaxEmbeddingsRetries": 3,
        "MaxEmbeddingsFailures": 3,
        "VectorStoreUrl": "http://localhost:8311/",
        "VectorStoreAccessKey": "***ault",
        "MaxContentLength": 16777216,
        "CreatedUtc": "2024-10-21T15:19:09.000000Z"
    },
    {
        "GUID": "another-embeddings-rule-guid",
        "TenantGUID": "default",
        "BucketGUID": "another-data-bucket",
        "OwnerGUID": "default",
        "Name": "Another embeddings rule",
        "ContentType": "text/plain",
        "GraphRepositoryGUID": "another-graph-repository",
        "VectorRepositoryGUID": "another-vector-repository",
        "ProcessingEndpoint": "http://localhost:8501/processor",
        "ProcessingAccessKey": "***ault",
        "MaxTokensPerChunk": 256,
        "TokenOverlap": 32,
        "EmbeddingsGenerator": "LCProxy",
        "EmbeddingsGeneratorUrl": "http://localhost:8301/",
        "EmbeddingsGeneratorApiKey": "***ault",
        "EmbeddingsBatchSize": 32,
        "MaxEmbeddingsTasks": 8,
        "MaxEmbeddingsRetries": 5,
        "MaxEmbeddingsFailures": 2,
        "VectorStoreUrl": "http://localhost:8311/",
        "VectorStoreAccessKey": "***ault",
        "MaxContentLength": 8388608,
        "CreatedUtc": "2024-10-21T16:45:30.000000Z"
    }
]

Update Embeddings Rule

Updates an existing embeddings rule configuration using PUT /v1.0/tenants/[tenant-guid]/embeddingsrule/[embeddingsrule-guid]. This endpoint allows you to modify embeddings rule parameters while preserving certain immutable fields.

Request Parameters

embeddingsrule-guid (string, Path, Required): GUID of the embeddings rule object to update

Updateable Fields

All configuration parameters can be updated except for:

GUID: Immutable identifier
TenantGUID: Immutable tenant association
CreatedUtc: Immutable creation timestamp

Important Notes

Field Preservation: Certain fields cannot be modified and will be preserved across updates
Complete Object: Provide a fully populated object in the request body
Validation: All updated parameters will be validated before applying changes

Request body:

curl --location --request PUT 'http://localhost:8000/v1.0/tenants/00000000-0000-0000-0000-000000000000/embeddingsrules/00000000-0000-0000-0000-000000000000' \
--header 'content-type: application/json' \
--header 'Authorization: ••••••' \
--data '{
    "BucketGUID": "00000000-0000-0000-0000-000000000000",
    "Name": "An updated embeddings rule",
    "ContentType": "*",
    "GraphRepositoryGUID": "00000000-0000-0000-0000-000000000000",
    "VectorRepositoryGUID": "00000000-0000-0000-0000-000000000000",
    "ProcessingEndpoint": "http://localhost:8000/v1.0/tenants/00000000-0000-0000-0000-000000000000/processing",
    "ProcessingAccessKey": "default",
    "EmbeddingsGenerator": "LCProxy",
    "EmbeddingsGeneratorUrl": "http://localhost:8000/v1.0/tenants/00000000-0000-0000-0000-000000000000/embeddings",
    "EmbeddingsGeneratorApiKey": "",
    "BatchSize": 512,
    "MaxGeneratorTasks": 32,
    "MaxRetries": 3,
    "MaxFailures": 3,
    "VectorStoreUrl": "http://localhost:8000/",
    "VectorStoreAccessKey": "default",
    "MaxContentLength": 16777216
}'

import { ViewConfigurationSdk } from "view-sdk";

const api = new ViewConfigurationSdk(
  "http://localhost:8000/", //endpoint
  "default", //tenant Id
  "default" //access key
);

const updateEmbeddingRule = async () => {
  try {
    const response = await api.EmbeddingRule.update({
      GUID: "<embeddingsrule-guid>",
      TenantGUID: "<tenant-guid>",
      BucketGUID: "<bucket-guid>",
      OwnerGUID: "<owner-guid>",
      Name: "Embeddings rule test updated",
      ContentType: "*",
      GraphRepositoryGUID: "<graph-repository-guid>",
      VectorRepositoryGUID: "<vector-repository-guid>",
      ProcessingEndpoint:
        "http://localhost:8000/v1.0/tenants/00000000-0000-0000-0000-000000000000/processing",
      ProcessingAccessKey: "***ault",
      EmbeddingsServerUrl:
        "http://nginx-processor:8000/v1.0/tenants/00000000-0000-0000-0000-000000000000/embeddings",
      EmbeddingsServerApiKey: "***ault",
      EmbeddingsGenerator: "LCProxy",
      EmbeddingsGeneratorUrl:
        "http://localhost:8000/v1.0/tenants/00000000-0000-0000-0000-000000000000/embeddings",
      EmbeddingsGeneratorApiKey: "",
      BatchSize: 512,
      MaxGeneratorTasks: 32,
      MaxRetries: 3,
      MaxFailures: 3,
      VectorStoreUrl: "http://localhost:8000/",
      VectorStoreAccessKey: "***ault",
      MaxContentLength: 16777216,
      CreatedUtc: "2025-03-26T09:37:15.386Z",
    });
    console.log(response, "Embedding rule updated successfully");
  } catch (err) {
    console.log("Error updating Embedding rule:", err);
  }
};

updateEmbeddingRule();

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

sdk = view_sdk.configure(
    access_key="default",
    base_url="localhost", 
    tenant_guid="default",
    service_ports={Service.DEFAULT: 8000},
)

def updateEmbeddingsRules():
    embeddingsRules = configuration.EmbeddingsRule.update("<embeddingsrule-guid>",
        BucketGUID="<bucket-guid>",
        Name="Embeddings rule [updated]",
        ContentType="*",
        GraphRepositoryGUID="<graph-repository-guid>",
        VectorRepositoryGUID="<vector-repository-guid>",
        ProcessingEndpoint="http://localhost:8000/v1.0/tenants/00000000-0000-0000-0000-000000000000/processing",
        ProcessingAccessKey="*****lt",
        EmbeddingsGenerator="LCProxy",
        EmbeddingsGeneratorUrl="http://localhost:8000/v1.0/tenants/00000000-0000-0000-0000-000000000000/embeddings",
        HuggingFaceApiKey="",
        EmbeddingsBatchSize=512,
        MaxGeneratorTasks=32,
        MaxEmbeddingsRetries=3,
        MaxEmbeddingsFailures=3,
        VectorStoreUrl="http://localhost:8000/",
        VectorStoreAccessKey="default",
        MaxContentLength=16777216
        )
    print(embeddingsRules)

updateEmbeddingsRules()

using View.Sdk;
using View.Sdk.Configuration;

ViewConfigurationSdk sdk = new ViewConfigurationSdk(Guid.Parse("<tenant-guid>"),"default", "http://localhost:8000/");
            
var request = new EmbeddingsRule
{
     GUID = Guid.Parse("<embeddingsrule-guid>"),
     TenantGUID = Guid.Parse("<tenant-guid>"),
     BucketGUID = Guid.Parse("<bucket-guid>"),
     OwnerGUID = Guid.Parse("<owner-guid>"),
     Name = "Embeddings rule test updated",
     ContentType = "*",
     GraphRepositoryGUID = Guid.Parse("<graph-repository-guid>"),
     VectorRepositoryGUID = Guid.Parse("<vector-repository-guid>"),
     ProcessingEndpoint = "http://localhost:8000/v1.0/tenants/00000000-0000-0000-0000-000000000000/processing",
     ProcessingAccessKey ="***ault",
     EmbeddingsServerUrl ="http://nginx-processor:8000/v1.0/tenants/00000000-0000-0000-0000-000000000000/embeddings",
     EmbeddingsServerApiKey ="***ault",
     EmbeddingsGenerator =EmbeddingsGeneratorEnum.LCProxy,
     EmbeddingsGeneratorUrl ="http://localhost:8000/v1.0/tenants/00000000-0000-0000-0000-000000000000/embeddings",
     EmbeddingsGeneratorApiKey ="",
     BatchSize =512,
     MaxGeneratorTasks =32,
     MaxRetries =3,
     MaxFailures =3,
     VectorStoreUrl ="http://localhost:8000/",
     VectorStoreAccessKey ="***ault",
     MaxContentLength =16777216,
};

EmbeddingsRule response = await sdk.EmbeddingsRule.Update(request);

Response

Returns the updated embeddings rule object with all configuration details:

{
    "GUID": "59f7c18d-7342-4aef-9308-86083459dd81",
    "TenantGUID": "default",
    "BucketGUID": "example-data-bucket",
    "OwnerGUID": "default",
    "Name": "My updated embeddings rule",
    "ContentType": "*",
    "GraphRepositoryGUID": "example-graph-repository",
    "VectorRepositoryGUID": "example-vector-repository",
    "ProcessingEndpoint": "http://localhost:8501/processor",
    "ProcessingAccessKey": "***ault",
    "ChunkingServerUrl": "http://nginx-chunker:8000/v1.0/tenants/00000000-0000-0000-0000-000000000000/chunking",
    "ChunkingServerApiKey": "***ault",
    "MaxChunkingTasks": 16,
    "MinChunkContentLength": 1,
    "MaxChunkContentLength": 1,
    "MaxTokensPerChunk": 1,
    "TokenOverlap": 32,
    "TokenizationModel": "sentence-transformers/all-MiniLM-L6-v2",
    "HuggingFaceApiKey": "***ault",
    "EmbeddingsServerUrl": "http://nginx-embeddings:8000/",
    "EmbeddingsServerApiKey": "***ault",
    "EmbeddingsGenerator": "LCProxy",
    "EmbeddingsGeneratorUrl": "http://localhost:8301/",
    "EmbeddingsGeneratorApiKey": "***ault",
    "EmbeddingsBatchSize": 16,
    "MaxEmbeddingsTasks": 16,
    "MaxEmbeddingsRetries": 3,
    "MaxEmbeddingsFailures": 3,
    "VectorStoreUrl": "http://localhost:8311/",
    "VectorStoreAccessKey": "***ault",
    "MaxContentLength": 16777216,
    "CreatedUtc": "2024-10-21T15:19:09.000000Z"
}

Delete Embeddings Rule

Deletes an embeddings rule object by GUID using DELETE /v1.0/tenants/[tenant-guid]/embeddingsrule/[embeddingsrule-guid]. This operation permanently removes the embeddings rule and stops all associated processing workflows. Use with caution as this action cannot be undone.

Request Parameters

embeddingsrule-guid (string, Path, Required): GUID of the embeddings rule object to delete

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

```javascript
import { ViewConfigurationSdk } from "view-sdk";

const api = new ViewConfigurationSdk(
  "http://localhost:8000/", //endpoint
  "default", //tenant Id
  "default" //access key
);

const deleteEmbeddingRule = async () => {
  try {
    const response = await api.EmbeddingRule.delete(
      "<embeddingsrule-guid>"
    );
    console.log(response, "Embedding rule deleted successfully");
  } catch (err) {
    console.log("Error deleting Embedding rule:", err);
  }
};

deleteEmbeddingRule();

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

sdk = view_sdk.configure(
    access_key="default",
    base_url="localhost", 
    tenant_guid="default",
    service_ports={Service.DEFAULT: 8000},
)

def deleteEmbeddingsRules():
    embeddingsRules = configuration.EmbeddingsRule.delete("<embeddingsrule-guid>")
    print(embeddingsRules)

deleteEmbeddingsRules()

using View.Sdk;
using View.Sdk.Configuration;

ViewConfigurationSdk sdk = new ViewConfigurationSdk(Guid.Parse("<tenant-guid>"),"default", "http://localhost:8000/");
        
bool deleted = await sdk.EmbeddingsRule.Delete(Guid.Parse("<embeddingsrule-guid>"));

Response

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

Check Embeddings Rule Existence

Verifies if an embeddings rule object exists without retrieving its configuration using HEAD /v1.0/tenants/[tenant-guid]/embeddingsrules/[embeddingsrule-guid]. This is an efficient way to check embeddings rule presence before performing operations.

Request Parameters

embeddingsrule-guid (string, Path, Required): GUID of the embeddings rule object to check

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

import { ViewConfigurationSdk } from "view-sdk";

const api = new ViewConfigurationSdk(
  "http://localhost:8000/", //endpoint
  "default", //tenant Id
  "default" //access key
);

const embeddingRuleExists = async () => {
  try {
    const response = await api.EmbeddingRule.exists(
      "<embeddingsrule-guid>"
    );
    console.log(response, "Embedding rule exists");
  } catch (err) {
    console.log("Error checking Embedding rule:", err);
  }
};

embeddingRuleExists();

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

sdk = view_sdk.configure(
    access_key="default",
    base_url="localhost", 
    tenant_guid="default",
    service_ports={Service.DEFAULT: 8000},
)

def existsEmbeddingsRules():
    embeddingsRules = configuration.EmbeddingsRule.exists("<embeddingsrule-guid>")
    print(embeddingsRules)

existsEmbeddingsRules()

using View.Sdk;
using View.Sdk.Configuration;

ViewConfigurationSdk sdk = new ViewConfigurationSdk(Guid.Parse("<tenant-guid>"),"default", "http://localhost:8000/");
        
bool exists = await sdk.EmbeddingsRule.Exists(Guid.Parse("<embeddingsrule-guid>"));

Response

200 No Content: Embeddings rule exists
404 Not Found: Embeddings rule 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 embeddings rule exists.

Best Practices

When configuring embeddings rules in the View platform, consider the following recommendations for optimal performance and reliability:

Content Type Filtering: Use specific content types instead of "*" when possible to improve processing efficiency
Chunk Size Optimization: Configure appropriate MinChunkContentLength and MaxChunkContentLength based on your content characteristics
Batch Size Tuning: Adjust EmbeddingsBatchSize based on your server capacity and processing requirements
API Key Security: Store and manage API keys securely, especially for HuggingFace and external services
Testing and Validation: Test embeddings rules with sample content before deploying to production

Next Steps

After successfully configuring embeddings rules, you can:

Content Processing: Upload content to configured buckets to trigger automated embeddings generation
Vector Search: Implement semantic search capabilities using generated vector embeddings
AI Applications: Build AI-powered applications that leverage processed text embeddings
Integration: Connect embeddings rules with other View platform services and APIs
Monitoring: Set up monitoring for embeddings processing workflows and performance metrics