Semantic Cell Management - View Vector Database

Overview

Semantic cells represent structured content units within documents, providing hierarchical organization and analysis capabilities for vector-based document processing. They serve as containers for semantic chunks and enable sophisticated content structure understanding within the View Vector Database platform.

Semantic cells are managed via the View Vector API at [http|https]://[hostname]:[port]/v1.0/tenants/[tenant-guid]/vectorrepositories/[vector-repository-guid]/documents/[document-guid]/cells and support comprehensive operations including cell retrieval, existence checking, and hierarchical content analysis.

Semantic Cell Object Structure

Semantic cells contain structured content units with hierarchical organization and analysis capabilities:

{
    "GUID": "b3f62afc-215c-45b5-88cd-678d0fe5a1e2",
    "CellType": "Paragraph",
    "MD5Hash": "a94a8fe5ccb19ba61c4c0873d391e987",
    "SHA1Hash": "1f8ac10f23c5b5bc1167bda84b833e5c057a77d2",
    "SHA256Hash": "9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08",
    "Position": 0,
    "Length": 120,
    "Chunks": [],
    "Children": []
}

Field Descriptions

GUID (string): Unique identifier for the semantic cell (may be auto-generated if not provided)
CellType (string): Type of the semantic cell, such as Paragraph, Sentence, Section, etc.
MD5Hash (string): MD5 hash of the content within the cell
SHA1Hash (string): SHA1 hash of the content within the cell
SHA256Hash (string): SHA256 hash of the content within the cell
Position (number): Starting position of the cell within the original content
Length (number): Length (in characters or bytes) of the semantic cell
Chunks (array): List of content chunks within this semantic cell
Children (array): Nested SemanticCell instances representing hierarchical structure

Read All Semantic Cells

Retrieves all semantic cells for a specific document using GET /v1.0/tenants/[tenant-guid]/vectorrepositories/[vector-repository-guid]/documents/[document-guid]/cells. Returns the complete hierarchical structure of semantic cells with their associated chunks and nested children.

Request Parameters

vector-repository-guid (string, Path, Required): GUID of the vector repository containing the document
document-guid (string, Path, Required): GUID of the document containing the semantic cells

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

import { ViewVectorProxySdk } from "view-sdk";

const api = new ViewVectorProxySdk(
  "http://localhost:8000/", //endpoint
  "<tenant-guid>", //tenant Id
  "default" //access key
);


const readSematicCells = async () => {
  try {
    const response = await api.SemanticCell.readAll(
      "<vector-repository-guid>",
      "<document-guid>"
    );
    console.log(response, "Read semantic cells response");
  } catch (err) {
    console.log("Error read semantic cells:", err);
  }
};

readSematicCells();

import view_sdk
from view_sdk import vector
from view_sdk.sdk_configuration import Service

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

def readSemanticCells():
    response = vector.SemanticCells.retrieve_all("<vector-repository-guid>","<document-guid>")
    print(response)

readSemanticCells()

using View.Sdk;
using View.Sdk.Vector;
using View.Sdk.Embeddings;
using View.Sdk.Semantic;

ViewVectorSdk sdk = new ViewVectorSdk(Guid.Parse("<tenant-guid>"),"default", "http://localhost:8000/");

Guid vectorRepoGuid = Guid.Parse("<vector-repository-guid>");
Guid documentGuid   = Guid.Parse("<document-guid>");

List<SemanticCell> cells = await sdk.SemanticCell.ReadMany(vectorRepoGuid, documentGuid);

Response

Returns an array of semantic cell objects with complete hierarchical structure, chunks, and metadata.

Read Single Semantic Cell

Retrieves a specific semantic cell by GUID using GET /v1.0/tenants/[tenant-guid]/vectorrepositories/[vector-repository-guid]/documents/[document-guid]/cells/[cell-guid]. Returns the complete semantic cell structure including chunks and nested children.

Request Parameters

vector-repository-guid (string, Path, Required): GUID of the vector repository containing the document
document-guid (string, Path, Required): GUID of the document containing the semantic cell
cell-guid (string, Path, Required): GUID of the semantic cell to retrieve

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

import { ViewVectorProxySdk } from "view-sdk";

const api = new ViewVectorProxySdk(
  "http://localhost:8000/", //endpoint
  "<tenant-guid>", //tenant Id
  "default" //access key
);

const readSematicCell = async () => {
  try {
    const response = await api.SemanticCell.read(
      "<vector-repository-guid>",
      "<document-guid>",
      "<cell-guid>"
    );
    console.log(response, "Read semantic cell response");
  } catch (err) {
    console.log("Error read semantic cell:", err);
  }
};
readSematicCell();

import view_sdk
from view_sdk import vector
from view_sdk.sdk_configuration import Service

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

def readSemanticCell():
    response = vector.SemanticCells.retrieve("<vector-repository-guid>","<document-guid>","<cell-guid>")
    print(response)

readSemanticCell()

using View.Sdk;
using View.Sdk.Vector;
using View.Sdk.Embeddings;
using View.Sdk.Semantic;

ViewVectorSdk sdk = new ViewVectorSdk(Guid.Parse("<vector-repository-guid>"),"default", "http://localhost:8000/");

Guid vectorRepoGuid = Guid.Parse("<vector-repository-guid>");
Guid documentGuid   = Guid.Parse("<document-guid>");
Guid cellGuid = Guid.Parse("<cell-guid>");

SemanticCell cell = await sdk.SemanticCell.Read(vectorRepoGuid, documentGuid, cellGuid);

Response

Returns the semantic cell object with complete structure, chunks, and metadata if found, or a 404 Not Found error if the cell doesn't exist.

Check Semantic Cell Existence

Checks whether a semantic cell exists using HEAD /v1.0/tenants/[tenant-guid]/vectorrepositories/[vector-repository-guid]/documents/[document-guid]/cells/[cell-guid]. Returns only HTTP status codes without response body for efficient existence verification.

Request Parameters

vector-repository-guid (string, Path, Required): GUID of the vector repository containing the document
document-guid (string, Path, Required): GUID of the document containing the semantic cell
cell-guid (string, Path, Required): GUID of the semantic cell to check

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

import { ViewVectorProxySdk } from "view-sdk";

const api = new ViewVectorProxySdk(
  "http://localhost:8000/", //endpoint
  "<tenant-guid>", //tenant Id
  "default" //access key
);

const SemanticCellsExist = async () => {
  try {
    const response = await api.SemanticCell.exists(
      "<vector-repository-guid>",
      "<document-guid>",
      "<cell-guid>"
    );
    console.log(response, "Semantic cells exist response");
  } catch (err) {
    console.log("Error semantic cells exist:", err);
  }
};
SemanticCellsExist();

import view_sdk
from view_sdk import vector
from view_sdk.sdk_configuration import Service

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

def existsSemanticCell():
    response = vector.SemanticCells.exists("<vector-repository-guid>","<document-guid>","<cell-guid>")
    print(response)

existsSemanticCell()

using View.Sdk;
using View.Sdk.Vector;
using View.Sdk.Embeddings;
using View.Sdk.Semantic;

ViewVectorSdk sdk = new ViewVectorSdk(Guid.Parse("<vector-repository-guid>"),"default", "http://localhost:8000/");

Guid vectorRepoGuid = Guid.Parse("<vector-repository-guid>");
Guid documentGuid   = Guid.Parse("<document-guid>");
Guid cellGuid = Guid.Parse("<cell-guid>");

SemanticCell cell = await sdk.SemanticCell.Exists(vectorRepoGuid, documentGuid, cellGuid);

Response

200 OK: Semantic cell exists
404 Not Found: Semantic cell 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 semantic cell exists.

Best Practices

When managing semantic cells in the View Vector Database, consider the following recommendations for optimal content structure analysis and hierarchical organization:

Cell Type Classification: Use appropriate cell types (Paragraph, Sentence, Section, etc.) to accurately represent content structure and enable effective analysis
Hierarchical Organization: Leverage the Children array to create meaningful document hierarchies that reflect content relationships and structure
Content Integrity: Ensure consistent hash values (MD5, SHA1, SHA256) for content verification and deduplication across semantic cells
Position Tracking: Maintain accurate position and length information for precise content location and analysis within documents
Chunk Management: Organize semantic chunks within cells to optimize vector processing and search performance

Next Steps

After successfully managing semantic cells, you can:

Semantic Chunks: Work with semantic chunks for detailed content analysis and vector embedding management
Vector Document Management: Create and manage vector documents with comprehensive semantic cell structures
Vector Search: Implement advanced vector search operations using semantic cell and chunk data
Content Analysis: Analyze document structure and content relationships using semantic cell hierarchies
AI Integration: Integrate semantic cell management with AI applications for sophisticated content understanding and processing