Integrate Hugging Face Serverless as an embedding provider

import { DataAPIClient, Table, InferTableSchema } from '@datastax/astra-db-ts';

const { ASTRA_DB_APPLICATION_TOKEN, ASTRA_DB_API_ENDPOINT } = process.env;

// Initialize the client and get a 'Db' object
const client = new DataAPIClient(ASTRA_DB_APPLICATION_TOKEN);
const db = client.db(ASTRA_DB_API_ENDPOINT);

console.log(`* Connected to DB ${db.id}`);

const tableDefinition = Table.schema({
  // Define all of the columns in the table
  columns: {
    // This column will store vector embeddings.
    // The Hugging Face Serverless integration
    // will automatically generate vector embeddings
    // for any text inserted to this column.
    example_vector: {
      type: "vector",
      dimension: MODEL_DIMENSIONS, // optional
      service: {
        provider: 'huggingface',
        modelName: 'MODEL_NAME',
        authentication: {
          providerKey: 'API_KEY_NAME',
        },
      },
    },
    // If you want to store the original text
    // in addition to the generated embeddings
    // you must create a separate column.
    original_text: "text",
  },
  // Define the primary key for the table.
  // You should change the primary key definition to meet the needs of your data.
  primaryKey: {
    partitionBy: ["original_text"],
  },
});

type TableSchema = InferTableSchema<typeof tableDefinition>;

(async function () {
  const table = await db.createTable<TableSchema>(
    'TABLE_NAME',
    { definition: tableDefinition },
  );

  console.log("Created table");

  // Index the vector column so that you can perform a vector search on it.
  await table.createVectorIndex(
    "example_vector_index",
    "example_vector",
    {
      options: {
        metric: 'SIMILARITY_METRIC', // optional
      },
    },
  );

  console.log("Indexed columns");
})();

import com.datastax.astra.client.DataAPIClient;
import com.datastax.astra.client.core.vector.SimilarityMetric;
import com.datastax.astra.client.core.vectorize.VectorServiceOptions;
import com.datastax.astra.client.databases.Database;
import com.datastax.astra.client.tables.Table;
import com.datastax.astra.client.tables.definition.TableDefinition;
import com.datastax.astra.client.tables.definition.columns.ColumnDefinitionVector;
import com.datastax.astra.client.tables.definition.indexes.TableVectorIndexDefinition;
import com.datastax.astra.client.tables.definition.rows.Row;

import java.util.HashMap;
import java.util.Map;

public class EmbeddingDemo {

  public static void main(String[] args) {
    // Loading Arguments
    String astraToken = System.getenv("ASTRA_DB_APPLICATION_TOKEN");
    String astraApiEndpoint = System.getenv("ASTRA_DB_API_ENDPOINT");

    // Initialize the client
    DataAPIClient client = new DataAPIClient(astraToken);
    System.out.println("Connected to AstraDB");

    Database database = client.getDatabase(astraApiEndpoint);
    System.out.println("Connected to Database.");

    // Define the columns and primary key for the table
    TableDefinition tableDefinition =
        new TableDefinition()
            // This column will store vector embeddings.
            // The Hugging Face Serverless integration
            // will automatically generate vector embeddings
            // for any text inserted to this column.
            .addColumnVector(
                "example_vector",
                new ColumnDefinitionVector()
                    .dimension(MODEL_DIMENSIONS) // optional
                    .metric(SimilarityMetric.SIMILARITY_METRIC)
                    .service(
                        new VectorServiceOptions()
                            .provider("huggingface")
                            .modelName("MODEL_NAME")
                            .authentication(Map.of("providerKey", "API_KEY_NAME"))
                    )
            )
            // If you want to store the original text
            // in addition to the generated embeddings
            // you must create a separate column.
            .addColumnText("original_text")
            // Define the primary key for the table.
            // You should change the primary key definition to meet the needs of your data.
            .addPartitionBy("original_text");

    Table<Row> table = database.createTable("TABLE_NAME", tableDefinition);

    System.out.println("Created table");

    // Index the vector column so that you can perform a vector search on it.
    TableVectorIndexDefinition definition =
        new TableVectorIndexDefinition().column("example_vector").metric(SimilarityMetric.SIMILARITY_METRIC);

    table.createVectorIndex("example_vector_index", definition);

    System.out.println("Indexed columns");
  }
}

curl -sS -L -X POST "$ASTRA_DB_API_ENDPOINT/api/json/v1/default_keyspace" \
--header "Token: $ASTRA_DB_APPLICATION_TOKEN" \
--header "Content-Type: application/json" \
--data '{
  "createTable": {
    "name": "TABLE_NAME",
    "definition": {
      "columns": {
        # This column will store vector embeddings.
        # The Hugging Face Serverless integration
        # will automatically generate vector embeddings
        # for any text inserted to this column.
        "example_vector": {
          "type": "vector",
          "dimension": MODEL_DIMENSIONS, # optional
          "service": {
            "provider": "huggingface",
            "modelName": "MODEL_NAME",
            "authentication": {
              "providerKey": "API_KEY_NAME"
            }
          }
        },
        # If you want to store the original text
        # in addition to the generated embeddings
        # you must create a separate column.
        "original_text": "text"
      },
      # Define the primary key for the table.
      # You should change the primary key definition to meet the needs of your data.
      "primaryKey": "original_text"
    }
  }
}'

curl -sS -L -X POST "$ASTRA_DB_API_ENDPOINT/api/json/v1/default_keyspace" \
--header "Token: $ASTRA_DB_APPLICATION_TOKEN" \
--header "Content-Type: application/json" \
--data '{
  "createVectorIndex": {
    "name": "example_vector_index",
    "definition": {
      "column": "example_vector",
      "options": {
        "metric": "SIMILARITY_METRIC"
      }
    }
  }
}'