Vantage ConsoleCommunityCustomer Support
Documentation

Management API

Account, collection, API keys and data upload functionalities of the Vantage API

Suggest Edits

The Management API is a collection of functionalities related to working with accounts, collections, Vantage and Model API keys, and data upload. Below, you can find different options and approaches for using these functionalities.

📘

Vantage Client

In the following code blocks, we're initializing the Vantage client using Vantage API key. For more information on client configuration, check out the API Usage page.

Management API

Account

Here you can find Account management functionalities provided by the Vantage API.

If you prefer a visual guide, check out the Console UI walkthrough example: See And Manage Account Details

Get Account

The following example returns details about the account ACCOUNT_ID.

from vantage_sdk import VantageClient

vantage_instance = VantageClient.using_vantage_api_key(
    vantage_api_key=VANTAGE_API_KEY,
    account_id=ACCOUNT_ID,
)

account = vantage_instance_stage.get_account()
print(account)

import { VantageClientConfiguration, VantageClient } from "@vantage-sdk";

const configuration: VantageClientConfiguration = {
    vantageApiKey: vantageApiKey,
    accountId: accountId, 
    
}
let client = new VantageClient(configuration)

let account = client.getAccount()

account.then(data => console.log(data))

import com.vantage.sdk.VantageClient;
import com.vantage.sdk.api.account.model.Account;

public static void main(String[] args) {
    final VantageClient client = VantageClient.usingVantageApiKey()
        .withAccountId(ACCOUNT_ID)
        .withVantageApiKey(VANTAGE_API_KEY)
        .build();

    final Account account = client.account().getActive();
}

./cli.py get-account

Update Account

The following example updates the account ACCOUNT_ID.

from vantage_sdk import VantageClient

vantage_instance = VantageClient.using_vantage_api_key(
    vantage_api_key=VANTAGE_API_KEY,
    account_id=ACCOUNT_ID,
)

account = vantage_instance_stage.update_account(
	account_name="New Account Name",
)
print(account)

import { VantageClientConfiguration, VantageClient } from "@vantage-sdk";

const configuration: VantageClientConfiguration = {
    vantageApiKey: vantageApiKey,
    accountId: accountId, 
    
}
let client = new VantageClient(configuration)

let account = client.updateAccount("New Account Name")

account.then(data => console.log(data))

import com.vantage.sdk.VantageClient;
import com.vantage.sdk.api.account.model.Account;

public static void main(String[] args) {
    final VantageClient client = VantageClient.usingVantageApiKey()
        .withAccountId(ACCOUNT_ID)
        .withVantageApiKey(VANTAGE_API_KEY)
        .build();

    final Account account = client.account().updateName("New Account Name");
}

./cli.py update-account "New Account Name"

Collections

Here you can find Collection management functionalities provided by the Vantage API.

If you prefer a visual guide, check out the Console UI walkthrough examples: Create Collections, Upload Data To Collection

List Collections

The following example returns all collections created by account ACCOUNT_ID.

from vantage_sdk import VantageClient

vantage_instance = VantageClient.using_vantage_api_key(
    vantage_api_key=VANTAGE_API_KEY,
    account_id=ACCOUNT_ID,
)

collections = vantage_instance_stage.list_collections()
print(collections)

import { VantageClientConfiguration, VantageClient } from "@vantage-sdk";

const configuration: VantageClientConfiguration = {
    vantageApiKey: vantageApiKey,
    accountId: accountId, 
    
}
let client = new VantageClient(configuration)

let collections = client.listCollections()

collections.then(data => console.log(data))

import java.util.List;
import com.vantage.sdk.VantageClient;
import com.vantage.sdk.api.collection.model.Collection;

public static void main(String[] args) {
    final VantageClient client = VantageClient.usingVantageApiKey()
        .withAccountId(ACCOUNT_ID)
        .withVantageApiKey(VANTAGE_API_KEY)
        .build();

    final List<Collection> collections = client
        .collections()
        .listCollections();
}

./cli.py list-collections

Get Collection

The following example returns details about the collection example-collection.

from vantage_sdk import VantageClient

vantage_instance = VantageClient.using_vantage_api_key(
    vantage_api_key=VANTAGE_API_KEY,
    account_id=ACCOUNT_ID,
)

collection = vantage_instance.get_collection(
  collection_id="example-collection"
)

print(collection)

import { VantageClientConfiguration, VantageClient } from "@vantage-sdk";

const configuration: VantageClientConfiguration = {
    vantageApiKey: vantageApiKey,
    accountId: accountId, 
    
}
let client = new VantageClient(configuration)

let collection = client.getCollection("node")

collection.then(data => console.log(data))

import com.vantage.sdk.VantageClient;
import com.vantage.sdk.api.collection.model.Collection;

public static void main(String[] args) {
    final VantageClient client = VantageClient.usingVantageApiKey()
        .withAccountId(ACCOUNT_ID)
        .withVantageApiKey(VANTAGE_API_KEY)
        .build();

    final Collection collection = client
        .collections()
        .getCollection("example-collection");
}

./cli.py get-collection example-collection

Create Collection

The following examples will demonstrate how you can create collection objects.

There are different types of collections, depending on whether you want Vantage to manage and create embeddings from your data, or if you prefer to provide them manually. The Python SDK provides two types of classes based on this distinction:

  • UserProvidedEmbeddingCollection and
  • VantageManagedEmbeddingCollection.

Further, depending on the LLM provider, which is either OpenAI or HuggingFace, Vantage-managed embedding collections are divided into OpenAICollection and HuggingFaceCollection classes. You should instantiate the appropriate one.

In the following examples, you can see how this is done. For more details and parameter descriptions, please check the Embeddings page of our documentation.

📘

Vantage-managed or User-provided Embeddings?

For more information on different collection types refer to our Collections or Embeddings documentation pages.

Vantage-managed embeddings

Below, you can see the code block representing the creation of two types of Vantage-managed embeddings collections.

The parameter that represents the actual embedding model (LLM) differs:

  • OpenAI collections require the llm parameter, where you can provide the OpenAI model name.
  • HuggingFace collections use the external_url parameter, which represents the endpoint URL of the deployed HF model.
from vantage_sdk import VantageClient
from vantage_sdk.model.collection import OpenAICollection

vantage_instance = VantageClient.using_vantage_api_key(
    vantage_api_key=VANTAGE_API_KEY,
    account_id=ACCOUNT_ID,
)

openai_collection_id = "vantage-managed-openai"

openai_collection = OpenAICollection(
    collection_id=openai_collection_id,
    embeddings_dimension=1536,
    llm="text-embedding-ada-002",
    external_account_id="YOUR_MODEL_API_KEY_ID",
)

created_collection = vantage_instance.create_collection(
    collection= openai_collection
)

print(created_collection)

from vantage_sdk import VantageClient
from vantage_sdk.model.collection import HuggingFaceCollection

vantage_instance = VantageClient.using_vantage_api_key(
    vantage_api_key=VANTAGE_API_KEY,
    account_id=ACCOUNT_ID,
)

openai_collection_id = "vantage-managed-huggingface"

hf_collection = HuggingFaceCollection(
    collection_id=hf_collection,
    embeddings_dimension=1536,
    external_url="HF_ENDPOINT_URL",
    external_account_id="YOUR_MODEL_API_KEY_ID",
)

created_collection = vantage_instance.create_collection(
    collection= hf_collection
)

print(created_collection)

import { VantageClientConfiguration, VantageClient, OpenAICollection } from "@vantage-sdk";

const configuration: VantageClientConfiguration = {
    vantageApiKey: vantageApiKey,
    accountId: accountId, 
    
}
let client = new VantageClient(configuration)

const collectionId = "openai-collection"

const newCollection: OpenAICollection = new OpenAICollection(
    collectionId,
    1536,
    "text-embedding-ada-002",
    undefined, // or LLM secret
    "EXTERNAL_KEY_ID"
)

const createdCollection = client.createCollection(newCollection)

createdCollection.then(data => console.log(data))

import { VantageClientConfiguration, VantageClient, HuggingFaceCollection } from "@vantage-sdk";

const configuration: VantageClientConfiguration = {
    vantageApiKey: vantageApiKey,
    accountId: accountId, 
    
}
let client = new VantageClient(configuration)

const collectionId = "hf-collection"

const newCollection: HuggingFaceCollection = new HuggingFaceCollection(
    collectionId,
    1536,
    "HF_ENDPOINT_URL",
    undefined, // or LLM secret
    "EXTERNAL_KEY_ID"
)

const createdCollection = client.createCollection(newCollection)

createdCollection.then(data => console.log(data))

import com.vantage.sdk.VantageClient;
import com.vantage.sdk.api.collection.model.OpenAICollection;

public static void main(String[] args) {
    final VantageClient client = VantageClient.usingVantageApiKey()
        .withAccountId(ACCOUNT_ID)
        .withVantageApiKey(VANTAGE_API_KEY)
        .build();

    final OpenAICollection collection = OpenAICollection.builder("my-openai-collection", 1536)
        .withLlmModel("text-embedding-ada-002")
        .withExternalKeyId(YOUR_OPENAI_SECRET_KEY)
        .build();
}

import com.vantage.sdk.VantageClient;
import com.vantage.sdk.api.collection.model.HuggingFaceCollection;

public static void main(String[] args) {
    final VantageClient client = VantageClient.usingVantageApiKey()
        .withAccountId(ACCOUNT_ID)
        .withVantageApiKey(VANTAGE_API_KEY)
        .build();

    final HuggingFaceCollection collection = HuggingFaceCollection.builder("my-hf-collection", 123)
        .withExternalUrl(YOUR_HF_ENDPOINT_URL)
        .withExternalKeyId(YOUR_MODEL_API_KEY_ID)
        .build();
}

./cli.py create-collection-openai \
    --collection-id 'my-openai-collection' \
    --embeddings-dimension 1536 \
    --llm-model-name 'text-embeddings-ada-002' \
    --llm-secret 'YOUR_OPENAI_SECRET_KEY'

./cli.py create-collection-hf \
    --collection-id 'my-hf-collection' \
    --embeddings-dimension 123 \
    --external-url 'YOUR_HF_ENDPOINT_URL' \
    --llm-secret 'YOUR_OPENAI_SECRET_KEY'

User-provided embeddings

The code block below describes how you can create a user-provided embeddings collection. It simply requires only the collection_id parameter and the embedding_dimensions.

from vantage_sdk import VantageClient
from vantage_sdk.model.collection import UserProvidedEmbeddingsCollection

vantage_instance = VantageClient.using_vantage_api_key(
    vantage_api_key=VANTAGE_API_KEY,
    account_id=ACCOUNT_ID,
)

upe_collection_id = "user-provided"

upe_collection = UserProvidedEmbeddingsCollection(
    collection_id=upe_collection_id,
    embeddings_dimension=123,
)

created_collection = vantage_instance.create_collection(
    collection= upe_collection
)

print(created_collection)

import { VantageClientConfiguration, VantageClient, UserProvidedEmbeddingsCollection } from "@vantage-sdk";

const configuration: VantageClientConfiguration = {
    vantageApiKey: vantageApiKey,
    accountId: accountId, 
    
}
let client = new VantageClient(configuration)

const collectionId = "user-provided"

const newCollection: UserProvidedEmbeddingsCollection = new UserProvidedEmbeddingsCollection(
    collectionId,
    1536,
)

const createdCollection = client.createCollection(newCollection)

createdCollection.then(data => console.log(data))

import com.vantage.sdk.VantageClient;
import com.vantage.sdk.api.collection.model.UserProvidedEmbeddingsCollection;

public static void main(String[] args) {
    final VantageClient client = VantageClient.usingVantageApiKey()
        .withAccountId(ACCOUNT_ID)
        .withVantageApiKey(VANTAGE_API_KEY)
        .build();

    final UserProvidedEmbeddingsCollection collection = UserProvidedEmbeddingsCollection.createNew(
        "my-upe-collection",
        "my-upe-collection",
        123
    );
}

./cli.py create-collection-upe  \
    --collection-id 'my-upe-collection' \
    --embeddings-dimension 123

Update Collection

The following example updates the collection example-collection.

from vantage_sdk import VantageClient

vantage_instance = VantageClient.using_vantage_api_key(
    vantage_api_key=VANTAGE_API_KEY,
    account_id=ACCOUNT_ID,
)

collection = vantage_instance.update_collection(
  collection_id="example-collection",
  collection_name="New Collection Name"
)

print(collection)

import { VantageClientConfiguration, VantageClient } from "@vantage-sdk";

const configuration: VantageClientConfiguration = {
    vantageApiKey: vantageApiKey,
    accountId: accountId, 
    
}
let client = new VantageClient(configuration)

const collectionId = "example-collection"

const updatedCollection = client.updateCollection(collectionId, "New Collection Name")

updatedCollection.then(data => console.log(data))

import com.vantage.sdk.VantageClient;
import com.vantage.sdk.api.collection.model.Collection;

public static void main(String[] args) {
    final VantageClient client = VantageClient.usingVantageApiKey()
        .withAccountId(ACCOUNT_ID)
        .withVantageApiKey(VANTAGE_API_KEY)
        .build();

    final Collection updatedCollection = client
        .collections()
        .update()
        .openAICollection("example-collection") // or huggingFaceCollection() or userProvidedEmbeddingsCollection()
        .withCollectionName("New Name")
        .execute();
}

./cli.py update-collection --collection-id example-collection --collection-name "New Name"

Delete Collection

The following example deletes the collection example-collection.

from vantage_sdk import VantageClient

vantage_instance = VantageClient.using_vantage_api_key(
    vantage_api_key=VANTAGE_API_KEY,
    account_id=ACCOUNT_ID,
)

vantage_instance.delete_collection(
  collection_id="example-collection",
)

import { VantageClientConfiguration, VantageClient } from "@vantage-sdk";

const configuration: VantageClientConfiguration = {
    vantageApiKey: vantageApiKey,
    accountId: accountId, 
    
}
let client = new VantageClient(configuration)

const collectionId = "example-collection"

client.deleteCollection(collectionId)

import com.vantage.sdk.VantageClient;

public static void main(String[] args) {
    final VantageClient client = VantageClient.usingVantageApiKey()
        .withAccountId(ACCOUNT_ID)
        .withVantageApiKey(VANTAGE_API_KEY)
        .build();

    client
        .collections()
        .deleteCollection(testCollection.getCollectionId());
}

./cli.py delete-collection example-collection

Model API Keys

Here you can find Model API Key management functionalities provided by the Vantage API. Note Model API Keys are the same as External Keys.

If you prefer a visual guide, check out the Console UI walkthrough example: Manage Your Model API Keys

List Model API Keys

The following example returns all Model API Keys created by account ACCOUNT_ID.

from vantage_sdk import VantageClient

vantage_instance = VantageClient.using_vantage_api_key(
    vantage_api_key=VANTAGE_API_KEY,
    account_id=ACCOUNT_ID,
)

model_keys = vantage_instance.get_external_api_keys()
print(model_keys)

import { VantageClientConfiguration, VantageClient } from "@vantage-sdk";

const configuration: VantageClientConfiguration = {
    vantageApiKey: vantageApiKey,
    accountId: accountId, 
    
}
let client = new VantageClient(configuration)

const keys = client.getExternalKeys()

keys.then(data => console.log(data))

import com.vantage.sdk.VantageClient;
import com.vantage.sdk.api.keys.external.model.ExternalKey;

public static void main(String[] args) {
    final VantageClient client = VantageClient.usingVantageApiKey()
        .withAccountId(ACCOUNT_ID)
        .withVantageApiKey(VANTAGE_API_KEY)
        .build();

    final List<ExternalKey> keys = client.keys()
        .externalKeys()
        .getExternalKeys();
}

./cli.py get-external-api-keys

Get Model API Key

The following example returns details about the Model API Key with id model-key-id.

from vantage_sdk import VantageClient

vantage_instance = VantageClient.using_vantage_api_key(
    vantage_api_key=VANTAGE_API_KEY,
    account_id=ACCOUNT_ID,
)

model_key = vantage_instance.get_external_api_key(
    external_key_id = "MODEL_KEY_ID"
)

print(model_key)

import { VantageClientConfiguration, VantageClient } from "@vantage-sdk";

const configuration: VantageClientConfiguration = {
    vantageApiKey: vantageApiKey,
    accountId: accountId, 
    
}
let client = new VantageClient(configuration)

const key = client.getExternalKey("MODEL_KEY_ID")

key.then(data => console.log(data))

import com.vantage.sdk.VantageClient;
import com.vantage.sdk.api.keys.external.model.ExternalKey;

public static void main(String[] args) {
    final VantageClient client = VantageClient.usingVantageApiKey()
        .withAccountId(ACCOUNT_ID)
        .withVantageApiKey(VANTAGE_API_KEY)
        .build();

    final ExternalKey key = client.keys()
        .externalKeys()
        .getExternalKey(MODEL_KEY_ID);
}

./cli.py get-external-api-key model-key-id

Create Model API Key

The following example creates new Model API Key.

from vantage_sdk import VantageClient

vantage_instance = VantageClient.using_vantage_api_key(
    vantage_api_key=VANTAGE_API_KEY,
    account_id=ACCOUNT_ID,
)

model_key = vantage_instance.create_external_api_key(
    llm_provider = "OpenAI",
    llm_secret = "LLM_SECRET",
)

print(model_key)

import { VantageClientConfiguration, VantageClient } from "@vantage-sdk";

const configuration: VantageClientConfiguration = {
    vantageApiKey: vantageApiKey,
    accountId: accountId, 
    
}
let client = new VantageClient(configuration)

const newKey = client.createExternalKey("OpenAI", "LLM_SECRET")

newKey.then(data => console.log(data))

import com.vantage.sdk.VantageClient;
import com.vantage.sdk.api.keys.external.model.ExternalKey;

public static void main(String[] args) {
    final VantageClient client = VantageClient.usingVantageApiKey()
        .withAccountId(ACCOUNT_ID)
        .withVantageApiKey(VANTAGE_API_KEY)
        .build();

    final ExternalKey key = client.keys()
        .externalKeys()
        .createExternalKey(
            LLMProviderType.OPEN_AI,
            LLM_SECRET
        );
}

./cli.py create-external-api-key \
  --llm-provider "Value" \
  --llm-secret "secret" \
  model-key-id

Update Model API Key

The following example updates the Model API Key with id model-key-id.

from vantage_sdk import VantageClient

vantage_instance = VantageClient.using_vantage_api_key(
    vantage_api_key=VANTAGE_API_KEY,
    account_id=ACCOUNT_ID,
)

updated_model_key = vantage_instance.update_external_api_key(
    external_key_id = "MODEL_KEY_ID",
    llm_provider = "OpenAI",
    llm_secret = "NEW_LLM_SECRET",
)

print(updated_model_key)
     

import { VantageClientConfiguration, VantageClient } from "@vantage-sdk";

const configuration: VantageClientConfiguration = {
    vantageApiKey: vantageApiKey,
    accountId: accountId, 
    
}
let client = new VantageClient(configuration)

const updatedKey = client.updateExternalKey("MODEL_KEY_ID", "NEW_LLM_SECRET")

updatedKey.then(data => console.log(data))

import com.vantage.sdk.VantageClient;
import com.vantage.sdk.api.keys.external.model.ExternalKey;

public static void main(String[] args) {
    final VantageClient client = VantageClient.usingVantageApiKey()
        .withAccountId(ACCOUNT_ID)
        .withVantageApiKey(VANTAGE_API_KEY)
        .build();

    final ExternalKey updatedKey = client.keys()
        .externalKeys()
        .updateExternalKey(
            MODEL_KEY_ID,
            LLMProviderType.OPEN_AI,
            NEW_LLM_SECRET
        );
}

./cli.py update-external-api-key \
  --llm-provider "New Value" \
  --llm-secret "new-secret" \
  model-key-id

Delete Model API Key

The following example deletes the Model API Key with id model-key-id.

from vantage_sdk import VantageClient

vantage_instance = VantageClient.using_vantage_api_key(
    vantage_api_key=VANTAGE_API_KEY,
    account_id=ACCOUNT_ID,
)

vantage_instance.delete_external_api_key(
    external_key_id = "MODEL_KEY_ID"
)

import { VantageClientConfiguration, VantageClient } from "@vantage-sdk";

const configuration: VantageClientConfiguration = {
    vantageApiKey: vantageApiKey,
    accountId: accountId, 
    
}
let client = new VantageClient(configuration)

client.deleteExternalKey("MODEL_KEY_ID")

import com.vantage.sdk.VantageClient;

public static void main(String[] args) {
    final VantageClient client = VantageClient.usingVantageApiKey()
        .withAccountId(ACCOUNT_ID)
        .withVantageApiKey(VANTAGE_API_KEY)
        .build();

    client.keys()
        .externalKeys()
        .deleteExternalKey(MODEL_KEY_ID);
}

./cli.py delete-external-api-key model-key-id

Vantage API Keys

Here you can find Vantage API key management functionalities provided by the Vantage API.

If you prefer a visual guide, check out the Console UI walkthrough example: Get Your Vantage API Key

List Vantage API Keys

The following example returns all Vantage API keys linked to account ACCOUNT_ID.

from vantage_sdk import VantageClient

vantage_instance = VantageClient.using_vantage_api_key(
    vantage_api_key=VANTAGE_API_KEY,
    account_id=ACCOUNT_ID,
)

vantage_keys = vantage_instance.get_vantage_api_keys()
print(vantage_keys)

import { VantageClientConfiguration, VantageClient } from "@vantage-sdk";

const configuration: VantageClientConfiguration = {
    vantageApiKey: vantageApiKey,
    accountId: accountId, 
    
}
let client = new VantageClient(configuration)

const keys = client.getVantageApiKeys()

keys.then(data => console.log(data))

import com.vantage.sdk.VantageClient;
import com.vantage.sdk.api.keys.vantage.model.VantageApiKey;

public static void main(String[] args) {
    final VantageClient client = VantageClient.usingVantageApiKey()
        .withAccountId(ACCOUNT_ID)
        .withVantageApiKey(VANTAGE_API_KEY)
        .build();

    final List<VantageApiKey> keys = client.keys()
        .vantage()
        .getApiKeys();
}

./cli.py get-vantage-api-keys

Get Vantage API Key

The following example returns details about the Vantage API key with id vantage-api-key-id.

from vantage_sdk import VantageClient

vantage_instance = VantageClient.using_vantage_api_key(
    vantage_api_key=VANTAGE_API_KEY,
    account_id=ACCOUNT_ID,
)

vantage_key = vantage_instance.get_vantage_api_key(
    vantage_api_key_id = "VANTAGE_API_KEY_ID"
)

print(vantage_key)

import { VantageClientConfiguration, VantageClient } from "@vantage-sdk";

const configuration: VantageClientConfiguration = {
    vantageApiKey: vantageApiKey,
    accountId: accountId, 
    
}
let client = new VantageClient(configuration)

const key = client.getVantageApiKey("VANTAGE_API_KEY_ID")

key.then(data => console.log(data))

import com.vantage.sdk.VantageClient;
import com.vantage.sdk.api.keys.vantage.model.VantageApiKey;

public static void main(String[] args) {
    final VantageClient client = VantageClient.usingVantageApiKey()
        .withAccountId(ACCOUNT_ID)
        .withVantageApiKey(VANTAGE_API_KEY)
        .build();

    final List<VantageApiKey> keys = client.keys()
        .vantage()
        .getApiKey(VANTAGE_API_KEY_ID);
}

./cli.py get-vantage-api-key vantage-api-key-id

Data Upload & Upsert

Vantage offers the possibility to upload or upsert documents to collections using multiple methods and data formats:

📘

Upload vs Upsert

Uploading your data will update your collection data and extend or upsert existing documents. Upserting will add new documents or update existing ones if the IDs match. Both do the same logical operation, just the upload or plumbing is different.

Upsert options:

  • Vantage Documents
    • upsert_documents
  • JSONL String
    • upsert_documents_from_jsonl_string
  • JSONL File
    • upsert_documents_from_jsonl_file

Upload options:

  • JSONL Format
    • upload_documents_from_jsonl_file
  • Parquet Format
    • upload_documents_from_parquet_file

Below are examples on how to use each of these methods.

Upsert Documents using Vantage Document objects - upsert_documents

Vantage offers multiple document upload options. Depending on the collection type, you can create either a UserProvidedEmbeddingsDocument or a VantageManagedEmbeddingsDocument object.

They differ in that the former requires an embeddings field, matching the embeddings_dimension set for the collection to which you are upserting data, while the latter does not. When upserting documents to a collection, you must upsert a list consisting solely of one of these document types.

Below, you can see a code block with examples of both of these cases.

from vantage_sdk import VantageClient

vantage_instance = VantageClient.using_vantage_api_key(
    vantage_api_key=VANTAGE_API_KEY,
    account_id=ACCOUNT_ID,
)

ids = [
    "1",
    "2",
    "3",
    "4",
]

texts = [
    "First text",
    "Second text",
    "Third text",
    "Fourth text",
]

# Suppose that the collection "example-upe-collection" has 
# the `embedding_dimension` parameter set to 3.
embeddings = [
    [0.123, 0.234, 0.345],
    [0.456, 0.567, 0.678],
    [0.789, 0.891, 0.912],
    [0.257, 0.389, 0.468],
]

documents = [
    UserProvidedEmbeddingsDocument(text=text, id=id, embeddings=emb)
    for id, text, emb in zip(ids, texts, embeddings)
]

vantage_instance.upsert_documents(
    collection_id="example-upe-collection",
    documents=documents
)

from vantage_sdk import VantageClient

vantage_instance = VantageClient.using_vantage_api_key(
    vantage_api_key=VANTAGE_API_KEY,
    account_id=ACCOUNT_ID,
)

ids = [
    "1",
    "2",
    "3",
    "4",
]

texts = [
    "First text",
    "Second text",
    "Third text",
    "Fourth text",
]

documents = [
    VantageManagedEmbeddingsDocument(text=text, id=id)
    for id, text in zip(ids, texts)
]

vantage_instance.upsert_documents(
    collection_id="example-vme-collection",
    documents=documents
)

import { VantageClientConfiguration, VantageClient, UserProvidedEmbeddingsDocument } from "@vantage-sdk";

const configuration: VantageClientConfiguration = {
    vantageApiKey: vantageApiKey,
    accountId: accountId, 
    
}
let client = new VantageClient(configuration)

const collectionId = "example-upe-collection"

const ids: string[] = [
    "1",
    "2",
    "3",
    "4",
];

const texts: string[] = [
    "First text",
    "Second text",
    "Third text",
    "Fourth text",
];

const embeddings = [
    [0.123, 0.234, 0.345],
    [0.456, 0.567, 0.678],
    [0.789, 0.891, 0.912],
    [0.257, 0.389, 0.468],
]

const documents: UserProvidedEmbeddingsDocument[] = ids.map((id, index) => new UserProvidedEmbeddingsDocument(texts[index], embeddings[index], id));

client.upsertDocuments(collectionId, documents);

import { VantageClientConfiguration, VantageClient, VantageManagedEmbeddingsDocument } from "@vantage-sdk";

const configuration: VantageClientConfiguration = {
    vantageApiKey: vantageApiKey,
    accountId: accountId, 
    
}
let client = new VantageClient(configuration)

const collectionId = "example-vme-collection"

const ids: string[] = [
    "1",
    "2",
    "3",
    "4",
];

const texts: string[] = [
    "First text",
    "Second text",
    "Third text",
    "Fourth text",
];

const documents: VantageManagedEmbeddingsDocument[] = ids.map((id, index) => new VantageManagedEmbeddingsDocument(texts[index], id));

client.upsertDocuments(collectionId, documents);

import com.vantage.sdk.VantageClient;
import com.vantage.sdk.api.document.model.UserProvidedEmbeddingsDocument;

public static void main(String[] args) {
    final VantageClient client = VantageClient.usingVantageApiKey()
        .withAccountId(ACCOUNT_ID)
        .withVantageApiKey(VANTAGE_API_KEY)
        .build();

    final UserProvidedEmbeddingsDocument document1 = UserProvidedEmbeddingsDocument.withoutMetadata(
        "First text",
        "1",
        List.of(0.123, 0.234, 0.345)
    );
    final UserProvidedEmbeddingsDocument document2 = UserProvidedEmbeddingsDocument.withoutMetadata(
        "Second text",
        "2",
        List.of(0.456, 0.567, 0.678)
    );
    final UserProvidedEmbeddingsDocument document3 = UserProvidedEmbeddingsDocument.withoutMetadata(
        "Third text",
        "3",
        List.of(0.789, 0.891, 0.912)
    );
    final UserProvidedEmbeddingsDocument document4 = UserProvidedEmbeddingsDocument.withoutMetadata(
        "Fourth text",
        "4",
        List.of(0.257, 0.389, 0.468)
    );

    final int status = client
        .documents()
        .upsert()
        .toCollection("example-upe-collection")
        .fromUserProvidedEmbeddingsDocuments(List.of(document1, document2, document3, document4))
        .execute();
}

import com.vantage.sdk.VantageClient;
import com.vantage.sdk.api.document.model.VantageManagedEmbeddingsDocument;

public static void main(String[] args) {
    final VantageClient client = VantageClient.usingVantageApiKey()
        .withAccountId(ACCOUNT_ID)
        .withVantageApiKey(VANTAGE_API_KEY)
        .build();

    final VantageManagedEmbeddingsDocument document1 = VantageManagedEmbeddingsDocument.withoutMetadata(
        "First text",
        "1"
    );
    final VantageManagedEmbeddingsDocument document2 = VantageManagedEmbeddingsDocument.withoutMetadata(
        "Second text",
        "2"
    );
    final VantageManagedEmbeddingsDocument document1 = VantageManagedEmbeddingsDocument.withoutMetadata(
        "Third text",
        "3"
    );
    final VantageManagedEmbeddingsDocument document2 = VantageManagedEmbeddingsDocument.withoutMetadata(
        "fourth text",
        "4"
    );

    final int status = client
        .documents()
        .upsert()
        .toCollection("example-vme-collection")
        .fromVantageManagedEmbeddingsDocuments(List.of(document1, document2, document3, document4))
        .execute();
}

Upsert Documents from JSONL string - upsert_documents_from_jsonl_string

There is a possibility to provide your document objects by manually creating your JSONL string. In that case, it's important to follow the Vantage JSONL data ingestion format. We highly recommend you take a look at our documentation page describing it.

Below is one example of how you can upsert documents using this approach.

from vantage_sdk import VantageClient

vantage_instance = VantageClient.using_vantage_api_key(
    vantage_api_key=VANTAGE_API_KEY,
    account_id=ACCOUNT_ID,
)

documents_jsonl = '{
  "id": "1", 
  "text": "Example text", 
  "meta_color": "green", 
  "embeddings": [1,2,3, ...]
}\\n{
  "id": "2", 
  "text": "Sample text", 
  "meta_color": "blue",
  "embeddings": [4,5,6, ...]
}'

vantage_instance.upsert_documents_from_jsonl_string(
    collection_id="example-collection",
    documents_jsonl=documents_jsonl
)

from vantage_sdk import VantageClient

vantage_instance = VantageClient.using_vantage_api_key(
    vantage_api_key=VANTAGE_API_KEY,
    account_id=ACCOUNT_ID,
)

documents_jsonl = '{
  "id": "1", 
  "text": "Example text", 
  "meta_color": "green",
}\\n{
  "id": "2", 
  "text": "Sample text", 
  "meta_color": "blue",
}'

vantage_instance.upsert_documents_from_jsonl_string(
    collection_id="example-collection",
    documents_jsonl=documents_jsonl
)

import { VantageClientConfiguration, VantageClient } from "@vantage-sdk";

const configuration: VantageClientConfiguration = {
    vantageApiKey: vantageApiKey,
    accountId: accountId, 
    
}
let client = new VantageClient(configuration)

const collectionId = "example-collection"

const documentsJsonl: string = '{\
  "id": "1", \
  "text": "Example text", \
  "meta_color": "green", \
  "embeddings": [1,2,3, ...]\
}\\n{\
  "id": "2", \
  "text": "Sample text", \
  "meta_color": "blue",\
  "embeddings": [4,5,6, ...]\
}'

client.upsertDocumentsFromJsonlString(collectionId, documentsJsonl);

import { VantageClientConfiguration, VantageClient } from "@vantage-sdk";

const configuration: VantageClientConfiguration = {
    vantageApiKey: vantageApiKey,
    accountId: accountId, 
    
}
let client = new VantageClient(configuration)

const collectionId = "example-collection"

const documentsJsonl: string = '{\
  "id": "1", \
  "text": "Example text", \
  "meta_color": "green", \
}\\n{\
  "id": "2", \
  "text": "Sample text", \
  "meta_color": "blue",\
}'

client.upsertDocumentsFromJsonlString(collectionId, documentsJsonl);

import com.vantage.sdk.VantageClient;

public static void main(String[] args) {
    final VantageClient client = VantageClient.usingVantageApiKey()
        .withAccountId(ACCOUNT_ID)
        .withVantageApiKey(VANTAGE_API_KEY)
        .build();

    final String jsonl = "{ "
        + "\"id\": \"1\", "
        + "\"text\": \"Example text\", "
        + "\"meta_color\": \"green\", "
        + "\"embeddings\": [ 1, 2, 3 ] "
        + "} { "
        + "\"id\": \"2\", "
        + "\"text\": \"Sample text\", "
        + "\"meta_color\": \"blue\", "
        + "\"embeddings\": [ 4, 5, 6 ] "
        + "}";

    final int status = client
        .documents()
        .upsert()
        .toCollection("example-collection")
        .fromString(jsonl)
        .execute();
}

import com.vantage.sdk.VantageClient;

public static void main(String[] args) {
    final VantageClient client = VantageClient.usingVantageApiKey()
        .withAccountId(ACCOUNT_ID)
        .withVantageApiKey(VANTAGE_API_KEY)
        .build();

    final String jsonl = "{ "
        + "\"id\": \"1\", "
        + "\"text\": \"Example text\", "
        + "\"meta_color\": \"green\" "
        + "} { "
        + "\"id\": \"2\", "
        + "\"text\": \"Sample text\", "
        + "\"meta_color\": \"blue\" "
        + "}";

    final int status = client
        .documents()
        .upsert()
        .toCollection("example-collection")
        .fromString(jsonl)
        .execute();
}

Upsert Documents from JSONL file - upsert_documents_from_jsonl_file

The following example upserts data from path_to_data.jsonl file to collection example-collection.

It's important to follow the Vantage JSONL data ingestion format. We highly recommend you take a look at our documentation page describing it.

from vantage_sdk import VantageClient

vantage_instance = VantageClient.using_vantage_api_key(
    vantage_api_key=VANTAGE_API_KEY,
    account_id=ACCOUNT_ID,
)

vantage_instance.upsert_documents_from_jsonl_file(
    collection_id="example-collection",
    jsonl_file_path="path_to_data.jsonl"
)

import { VantageClientConfiguration, VantageClient } from "@vantage-sdk";

const configuration: VantageClientConfiguration = {
    vantageApiKey: vantageApiKey,
    accountId: accountId, 
    
}
let client = new VantageClient(configuration)

const collectionId = "example_collection"

client.upsertDocumentsFromJsonlFile(collectionId, "path_to_data.jsonl");

import com.vantage.sdk.VantageClient;

public static void main(String[] args) {
    final VantageClient client = VantageClient.usingVantageApiKey()
        .withAccountId(ACCOUNT_ID)
        .withVantageApiKey(VANTAGE_API_KEY)
        .build();

    final int status = client
        .documents()
        .upsert()
        .toCollection("example-collection")
        .fromPath("path_to_data.jsonl")
        .withIdentifier(jsonlFile)
        .execute();

./cli.py upsert-documents-from-jsonl --collection-id example-collection "path_to_data.jsonl"

Upload Documents from JSONL file - upload_documents_from_jsonl_file

The following example uploads data from path_to_data.jsonl file to collection example-collection.

It's important to follow the Vantage JSONL data ingestion format. We highly recommend you take a look at our documentation page describing it.

from vantage_sdk import VantageClient

vantage_instance = VantageClient.using_vantage_api_key(
    vantage_api_key=VANTAGE_API_KEY,
    account_id=ACCOUNT_ID,
)

vantage_instance.upload_documents_from_jsonl_file(
    collection_id="example-collection",
    parquet_file_path="path_to_data.jsonl"
)

import { VantageClientConfiguration, VantageClient } from "@vantage-sdk";

const configuration: VantageClientConfiguration = {
    vantageApiKey: vantageApiKey,
    accountId: accountId, 
    
}
let client = new VantageClient(configuration)

const collectionId = "example_collection"

client.uploadDocumentsFromParquetFile(collectionId, "path_to_data.parquet");

import com.vantage.sdk.VantageClient;

public static void main(String[] args) {
    final VantageClient client = VantageClient.usingVantageApiKey()
        .withAccountId(ACCOUNT_ID)
        .withVantageApiKey(VANTAGE_API_KEY)
        .build();

    final int status = client
        .documents()
        .upload()
        .toCollection("example-collection")
        .jsonlFile()
        .fromPath("path_to_data.jsonl")
        .execute();

./cli.py upload-documents-from-jsonl --collection-id example-collection "path_to_data.jsonl"

Upload Documents from Parquet file - upload_documents_from_parquet_file

The following example uploads data from path_to_data.parquet file to collection example-collection.

It's important to follow the Vantage Parquet data ingestion format. We highly recommend you take a look at our documentation page describing it.

from vantage_sdk import VantageClient

vantage_instance = VantageClient.using_vantage_api_key(
    vantage_api_key=VANTAGE_API_KEY,
    account_id=ACCOUNT_ID,
)

vantage_instance.upload_documents_from_parquet_file(
    collection_id="example-collection",
    parquet_file_path="path_to_data.parquet"
)

import { VantageClientConfiguration, VantageClient } from "@vantage-sdk";

const configuration: VantageClientConfiguration = {
    vantageApiKey: vantageApiKey,
    accountId: accountId, 
    
}
let client = new VantageClient(configuration)

const collectionId = "example_collection"

client.uploadDocumentsFromParquetFile(collectionId, "path_to_data.parquet");

import com.vantage.sdk.VantageClient;

public static void main(String[] args) {
    final VantageClient client = VantageClient.usingVantageApiKey()
        .withAccountId(ACCOUNT_ID)
        .withVantageApiKey(VANTAGE_API_KEY)
        .build();

    final int status = client
        .documents()
        .upload()
        .toCollection("example-collection")
        .parquetFile()
        .fromPath("path_to_data.parquet")
        .execute();

./cli.py upload-documents-from-parquet --collection-id example-collection "path_to_data.parquet"

Shopping Assistant

Here you can find Shopping Assistant management functionalities provided by the Vantage API.

List Shopping Assistants

The Following example returns all Shopping Assistant configurations created by user.

from vantage_sdk import VantageClient

vantage_instance = VantageClient.using_vantage_api_key(
    vantage_api_key=VANTAGE_API_KEY,
    account_id=ACCOUNT_ID,
)

shopping_assistants = vantage_instance.list_shopping_assistants()

import { VantageClientConfiguration, VantageClient } from "@vantage-sdk";

const configuration: VantageClientConfiguration = {
    vantageApiKey: vantageApiKey,
    accountId: accountId, 
    
}
let client = new VantageClient(configuration)

const assistants = await client.listShoppingAssistants()

final VantageClient client = VantageClient.usingVantageApiKey()
    .withAccountId(ACCOUNT_ID)
    .withVantageApiKey(VANTAGE_API_KEY)
    .build();

final List<ShoppingAssistant> shoppingAssistants = client
    .shoppingAssistants()
    .list();

Get Shopping Assistant

The following example returns a specific Shopping Assistant configuration.

from vantage_sdk import VantageClient

vantage_instance = VantageClient.using_vantage_api_key(
    vantage_api_key=VANTAGE_API_KEY,
    account_id=ACCOUNT_ID,
)

shopping_assistant_id = "shopping-assistant-id"

shopping_assistant = vantage_instance.get_shopping_assistant(
    shopping_assistant_id
)

import { VantageClientConfiguration, VantageClient } from "@vantage-sdk";

const configuration: VantageClientConfiguration = {
    vantageApiKey: vantageApiKey,
    accountId: accountId, 
    
}
let client = new VantageClient(configuration)

const shoppingAssistantId = "shopping-assistant-id"

const assistant = await client.getShoppingAssistant(
    shoppingAssistantId,
)

final VantageClient client = VantageClient.usingVantageApiKey()
    .withAccountId(ACCOUNT_ID)
    .withVantageApiKey(VANTAGE_API_KEY)
    .build();

final ShoppingAssistant shoppingAssistant = client
    .shoppingAssistants()
    .get(SHOPPING_ASSISTANT_ID);

Create Shopping Assistant

The Following example creates new Shopping Assistant configuration.

from vantage_sdk import VantageClient

vantage_instance = VantageClient.using_vantage_api_key(
    vantage_api_key=VANTAGE_API_KEY,
    account_id=ACCOUNT_ID,
)

name = "assistant"
groups = ["group 1", "group 2", "group 3"]
external_account_id = "external-account-id"
llm_model_name = "text-embeddings-ada-002"

shopping_assistant = vantage_instance.create_shopping_assistant(
    name=name,
    groups=groups,
    external_account_id=external_account_id,
    llm_model_name=llm_model_name,
)

import { VantageClientConfiguration, VantageClient } from "@vantage-sdk";

const configuration: VantageClientConfiguration = {
    vantageApiKey: vantageApiKey,
    accountId: accountId, 
    
}
let client = new VantageClient(configuration)

const name = "assistant"
const groups = [
        "group 1",
        "group 2",
        "group 3"
    ]
const externalAccountId = "external-account-id"
const llmModelName = "text-embeddings-ada-002"

const assistant = await client.createShoppingAssistant(
    name,
    groups,
    externalAccountId,
    llmModelName
)

final VantageClient client = VantageClient.usingVantageApiKey()
    .withAccountId(ACCOUNT_ID)
    .withVantageApiKey(VANTAGE_API_KEY)
    .build();

final ShoppingAssistant shoppingAssistant = ShoppingAssistant.createNew(
    "Example assistant",
    List.of("Shorts", "Shirts", "BBQ"),
    "f7de5b09-0393-408e-abc8-0139ca8a6de2",
    "openai-4o"
);

final ShoppingAssistant createdChoppingAssistant = client
    .shoppingAssistants()
    .create(shoppingAssistant);

Update Shopping Assistant

The Following example updates an existing Shopping Assistant configuration.

from vantage_sdk import VantageClient

vantage_instance = VantageClient.using_vantage_api_key(
    vantage_api_key=VANTAGE_API_KEY,
    account_id=ACCOUNT_ID,
)

name = "new name"

shopping_assistant = vantage_instance.update_shopping_assistant(
    name=name,
)

import { VantageClientConfiguration, VantageClient } from "@vantage-sdk";

const configuration: VantageClientConfiguration = {
    vantageApiKey: vantageApiKey,
    accountId: accountId, 
    
}
let client = new VantageClient(configuration)

const newName = "new name"

const assistant = await client.updateShoppingAssistant(
    newName,
)

final VantageClient client = VantageClient.usingVantageApiKey()
    .withAccountId(ACCOUNT_ID)
    .withVantageApiKey(VANTAGE_API_KEY)
    .build();

final ShoppingAssistant response = client
    .shoppingAssistants()
    .update(EXISTING_ASSISTANT_ID)
    .withExternalAccountId("cae9db26-cb0a-4e2e-8aad-61cdac66e617")
    .withLlmModelName("openai-4o")
    .withGroups(List.of("Rakes", "Shovels"))
    .withName("Updated example name")
    .execute();

Delete Shopping Assistant

The Following example deletes an existing Shopping Assistant configuration.

from vantage_sdk import VantageClient

vantage_instance = VantageClient.using_vantage_api_key(
    vantage_api_key=VANTAGE_API_KEY,
    account_id=ACCOUNT_ID,
)

shopping_assistant_id = "shopping-assistant-id"

vantage_instance.delete_shopping_assistant(shopping_assistant_id)

import { VantageClientConfiguration, VantageClient } from "@vantage-sdk";

const configuration: VantageClientConfiguration = {
    vantageApiKey: vantageApiKey,
    accountId: accountId, 
    
}
let client = new VantageClient(configuration)

const shoppingAssistantId = "shopping-assistant-id"

await client.deleteShoppingAssistant(
    shoppingAssistantId
)

final VantageClient client = VantageClient.usingVantageApiKey()
    .withAccountId(ACCOUNT_ID)
    .withVantageApiKey(VANTAGE_API_KEY)
    .build();

final ShoppingAssistant response = client
    .shoppingAssistants()
    .delete(EXISTING_ASSISTANT_ID);

Vantage Vibe

Here you can find Vantage Vibe management functionalities provided by the Vantage API.

List Vantage Vibe Configurations

The Following example returns all Vantage Vibe configurations created by user.

from vantage_sdk import VantageClient

vantage_instance = VantageClient.using_vantage_api_key(
    vantage_api_key=VANTAGE_API_KEY,
    account_id=ACCOUNT_ID,
)

vibes = client.list_vibe_configurations()

import { VantageClientConfiguration, VantageClient } from "@vantage-sdk";

const configuration: VantageClientConfiguration = {
    vantageApiKey: vantageApiKey,
    accountId: accountId, 
    
}
let client = new VantageClient(configuration)

const vibes = await client.listVibeConfigurations()

final VantageClient client = VantageClient.usingVantageApiKey()
    .withAccountId(ACCOUNT_ID)
    .withVantageApiKey(VANTAGE_API_KEY)
    .build();

final List<VibeConfiguration> vibes = client
    .vibe()
    .list();

Get Vantage Vibe Configuration

The following example returns a specific Vantage Vibe configuration.

from vantage_sdk import VantageClient

vantage_instance = VantageClient.using_vantage_api_key(
    vantage_api_key=VANTAGE_API_KEY,
    account_id=ACCOUNT_ID,
)

vibe_id = "vibe-id"

vibe = client.get_vibe_configuration(vibe_id)

import { VantageClientConfiguration, VantageClient } from "@vantage-sdk";

const configuration: VantageClientConfiguration = {
    vantageApiKey: vantageApiKey,
    accountId: accountId, 
    
}
let client = new VantageClient(configuration)

 const vibeId = "vibe-id"

const vibe = await client.getVibeConfiguration(
    vibeId,
)

final VantageClient client = VantageClient.usingVantageApiKey()
    .withAccountId(ACCOUNT_ID)
    .withVantageApiKey(VANTAGE_API_KEY)
    .build();

final VibeConfiguration vibe = client
    .vibe()
    .get("vibe-id");

Create Vantage Vibe Configuration

The Following example creates new Vantage Vibe configuration.

from vantage_sdk import VantageClient

vantage_instance = VantageClient.using_vantage_api_key(
    vantage_api_key=VANTAGE_API_KEY,
    account_id=ACCOUNT_ID,
)

name = "example-vibe"
external_account_id = "external-account-id"
llm_model_name = "text-embeddings-ada-002"

vibe = client.create_vibe_configuration(
    name=name,
    external_account_id=external_account_id,
    llm_model_name=llm_model_name,
)

import { VantageClientConfiguration, VantageClient } from "@vantage-sdk";

const configuration: VantageClientConfiguration = {
    vantageApiKey: vantageApiKey,
    accountId: accountId, 
    
}
let client = new VantageClient(configuration)

const name = "example-vibe"
const externalAccountId = "external-account-id"
const llmModelName = "text-embeddings-ada-002"

const vibe = await client.createVibeConfiguration(
    name,
    llmModelName,
    externalAccountId
)

final VantageClient client = VantageClient.usingVantageApiKey()
    .withAccountId(ACCOUNT_ID)
    .withVantageApiKey(VANTAGE_API_KEY)
    .build();

final VibeConfiguration vibe = VibeConfiguration.createNew(
    "text-embeddings-ada-002",
    "example-vibe",
    "external-account-id"
);

final VibeConfiguration response = client
    .vibe()
    .create(vibe);

Delete Vantage Vibe Configuration

The Following example deletes an existing Vantage Vibe configuration.

from vantage_sdk import VantageClient

vantage_instance = VantageClient.using_vantage_api_key(
    vantage_api_key=VANTAGE_API_KEY,
    account_id=ACCOUNT_ID,
)

test_vibe_id = "vibe-id"

client.delete_vibe_configuration(test_vibe_id)

import { VantageClientConfiguration, VantageClient } from "@vantage-sdk";

const configuration: VantageClientConfiguration = {
    vantageApiKey: vantageApiKey,
    accountId: accountId, 
    
}
let client = new VantageClient(configuration)

const vibeId = "vibe-id"

await client.deleteVibeConfiguration(
    vibeId
)

final VantageClient client = VantageClient.usingVantageApiKey()
    .withAccountId(ACCOUNT_ID)
    .withVantageApiKey(VANTAGE_API_KEY)
    .build();

client
    .vibe()
    .delete("vibe-id");

Updated about 1 month ago