chromadb 1.7.2 → 1.7.3-beta2

package/src/AdminClient.ts

@@ -1,272 +0,0 @@
-import { Configuration, ApiApi as DefaultApi } from "./generated";
-import { handleSuccess, handleError, validateTenantDatabase } from "./utils";
-import { ConfigOptions } from './types';
-import {
-    AuthOptions,
-    ClientAuthProtocolAdapter,
-    IsomorphicFetchClientAuthProtocolAdapter
-} from "./auth";
-
-const DEFAULT_TENANT = "default_tenant"
-const DEFAULT_DATABASE = "default_database"
-
-// interface for tenant
-interface Tenant {
-    name: string,
-}
-
-// interface for tenant
-interface Database {
-    name: string,
-}
-
-export class AdminClient {
-    /**
-     * @ignore
-     */
-    private api: DefaultApi & ConfigOptions;
-    private apiAdapter: ClientAuthProtocolAdapter<any>|undefined;
-    public tenant: string = DEFAULT_TENANT;
-    public database: string = DEFAULT_DATABASE;
-
-    /**
-     * Creates a new AdminClient instance.
-     * @param {Object} params - The parameters for creating a new client
-     * @param {string} [params.path] - The base path for the Chroma API.
-     * @returns {AdminClient} A new AdminClient instance.
-     *
-     * @example
-     * ```typescript
-     * const client = new AdminClient({
-     *   path: "http://localhost:8000"
-     * });
-     * ```
-     */
-    constructor({
-        path,
-        fetchOptions,
-        auth,
-        tenant = DEFAULT_TENANT,
-        database = DEFAULT_DATABASE
-    }: {
-        path?: string,
-        fetchOptions?: RequestInit,
-        auth?: AuthOptions,
-        tenant?: string,
-        database?: string,
-    } = {}) {
-        if (path === undefined) path = "http://localhost:8000";
-        this.tenant = tenant;
-        this.database = database;
-
-        const apiConfig: Configuration = new Configuration({
-            basePath: path,
-        });
-        if (auth !== undefined) {
-            this.apiAdapter = new IsomorphicFetchClientAuthProtocolAdapter(new DefaultApi(apiConfig), auth);
-            this.api = this.apiAdapter.getApi();
-        } else {
-            this.api = new DefaultApi(apiConfig);
-        }
-
-        this.api.options = fetchOptions ?? {};
-    }
-
-    /**
-     * Sets the tenant and database for the client.
-     *
-     * @param {Object} params - The parameters for setting tenant and database.
-     * @param {string} params.tenant - The name of the tenant.
-     * @param {string} params.database - The name of the database.
-     *
-     * @returns {Promise<void>} A promise that returns nothing
-     * @throws {Error} Any issues
-     *
-     * @example
-     * ```typescript
-     * await adminClient.setTenant({
-     *   tenant: "my_tenant",
-     *   database: "my_database",
-     * });
-     * ```
-     */
-    public async setTenant({
-        tenant = DEFAULT_TENANT,
-        database = DEFAULT_DATABASE
-    }: {
-        tenant: string,
-        database?: string,
-    }): Promise<void> {
-        await validateTenantDatabase(this, tenant, database);
-        this.tenant = tenant;
-        this.database = database;
-    }
-
-    /**
-     * Sets the database for the client.
-     *
-     * @param {Object} params - The parameters for setting the database.
-     * @param {string} params.database - The name of the database.
-     *
-     * @returns {Promise<void>} A promise that returns nothing
-     * @throws {Error} Any issues
-     *
-     * @example
-     * ```typescript
-     * await adminClient.setDatabase({
-     *   database: "my_database",
-     * });
-     * ```
-     */
-    public async setDatabase({
-        database = DEFAULT_DATABASE
-    }: {
-        database?: string,
-    }): Promise<void> {
-        await validateTenantDatabase(this, this.tenant, database);
-        this.database = database;
-    }
-
-    /**
-     * Creates a new tenant with the specified properties.
-     *
-     * @param {Object} params - The parameters for creating a new tenant.
-     * @param {string} params.name - The name of the tenant.
-     *
-     * @returns {Promise<Tenant>} A promise that resolves to the created tenant.
-     * @throws {Error} If there is an issue creating the tenant.
-     *
-     * @example
-     * ```typescript
-     * await adminClient.createTenant({
-     *   name: "my_tenant",
-     * });
-     * ```
-     */
-    public async createTenant({
-        name,
-    }: {
-        name: string,
-    }): Promise<Tenant> {
-        const newTenant = await this.api
-            .createTenant({name}, this.api.options)
-            .then(handleSuccess)
-            .catch(handleError);
-
-        // newTenant is null if successful
-        if (newTenant && newTenant.error) {
-            throw new Error(newTenant.error);
-        }
-
-        return {name: name} as Tenant
-    }
-
-    /**
-     * Gets a tenant with the specified properties.
-     *
-     * @param {Object} params - The parameters for getting a tenant.
-     * @param {string} params.name - The name of the tenant.
-     *
-     * @returns {Promise<Tenant>} A promise that resolves to the tenant.
-     * @throws {Error} If there is an issue getting the tenant.
-     *
-     * @example
-     * ```typescript
-     * await adminClient.getTenant({
-     *   name: "my_tenant",
-     * });
-     * ```
-     */
-    public async getTenant({
-        name,
-    }: {
-        name: string,
-    }): Promise<Tenant> {
-        const getTenant = await this.api
-            .getTenant(name, this.api.options)
-            .then(handleSuccess)
-            .catch(handleError);
-
-        if (getTenant.error) {
-            throw new Error(getTenant.error);
-        }
-
-        return {name: getTenant.name} as Tenant
-    }
-
-    /**
-     * Creates a new database with the specified properties.
-     *
-     * @param {Object} params - The parameters for creating a new database.
-     * @param {string} params.name - The name of the database.
-     * @param {string} params.tenantName - The name of the tenant.
-     *
-     * @returns {Promise<Database>} A promise that resolves to the created database.
-     * @throws {Error} If there is an issue creating the database.
-     *
-     * @example
-     * ```typescript
-     * await adminClient.createDatabase({
-     *   name: "my_database",
-     *   tenantName: "my_tenant",
-     * });
-     * ```
-     */
-    public async createDatabase({
-        name,
-        tenantName
-    }: {
-        name: string,
-        tenantName: string,
-    }): Promise<Database> {
-        const newDatabase = await this.api
-            .createDatabase(tenantName, {name}, this.api.options)
-            .then(handleSuccess)
-            .catch(handleError);
-
-        // newDatabase is null if successful
-        if (newDatabase && newDatabase.error) {
-            throw new Error(newDatabase.error);
-        }
-
-        return {name: name} as Database
-    }
-
-    /**
-     * Gets a database with the specified properties.
-     *
-     * @param {Object} params - The parameters for getting a database.
-     * @param {string} params.name - The name of the database.
-     * @param {string} params.tenantName - The name of the tenant.
-     *
-     * @returns {Promise<Database>} A promise that resolves to the database.
-     * @throws {Error} If there is an issue getting the database.
-     *
-     * @example
-     * ```typescript
-     * await adminClient.getDatabase({
-     *   name: "my_database",
-     *   tenantName: "my_tenant",
-     * });
-     * ```
-     */
-    public async getDatabase({
-        name,
-        tenantName
-    }: {
-        name: string,
-        tenantName: string,
-    }): Promise<Database> {
-        const getDatabase = await this.api
-            .getDatabase(name, tenantName, this.api.options)
-            .then(handleSuccess)
-            .catch(handleError);
-
-        if (getDatabase.error) {
-            throw new Error(getDatabase.error);
-        }
-
-        return {name: getDatabase.name} as Database
-    }
-
-}

package/src/CloudClient.ts

@@ -1,46 +0,0 @@
-
-// create a cloudclient class that takes in an api key and an optional database
-// this should wrap ChromaClient and specify the auth scheme correctly
-
-import { ChromaClient } from "./ChromaClient";
-
-interface CloudClientParams {
-    apiKey?: string;
-    database?: string;
-    cloudHost?: string;
-    cloudPort?: string;
-}
-
-class CloudClient extends ChromaClient{
-
-    constructor({apiKey, database, cloudHost, cloudPort}: CloudClientParams)  {
-        // If no API key is provided, try to load it from the environment variable
-        if (!apiKey) {
-            apiKey = process.env.CHROMA_API_KEY;
-        }
-        if (!apiKey) {
-            throw new Error("No API key provided");
-        }
-
-        cloudHost = cloudHost || "https://api.trychroma.com";
-        cloudPort = cloudPort || "8000";
-
-        const path = `${cloudHost}:${cloudPort}`;
-
-        const auth =  {
-                provider: "token",
-                credentials: apiKey,
-                providerOptions: { headerType: "X_CHROMA_TOKEN" },
-            }
-
-        return new ChromaClient({
-            path: path,
-            auth: auth,
-            database: database,
-        })
-
-        super()
-    }
-}
-
-export { CloudClient };

package/src/embeddings/GoogleGeminiEmbeddingFunction.ts

@@ -1,69 +0,0 @@
-import { IEmbeddingFunction } from "./IEmbeddingFunction";
-
-let googleGenAiApi: any;
-
-export class GoogleGenerativeAiEmbeddingFunction implements IEmbeddingFunction {
-    private api_key: string;
-    private model: string;
-    private googleGenAiApi?: any;
-    private taskType: string;
-
-    constructor({ googleApiKey, model, taskType }: { googleApiKey: string, model?: string, taskType?: string }) {
-        // we used to construct the client here, but we need to async import the types
-        // for the openai npm package, and the constructor can not be async
-        this.api_key = googleApiKey;
-        this.model = model || "embedding-001";
-        this.taskType = taskType || "RETRIEVAL_DOCUMENT";
-    }
-
-    private async loadClient() {
-        if(this.googleGenAiApi) return;
-        try {
-            // eslint-disable-next-line global-require,import/no-extraneous-dependencies
-            const { googleGenAi } = await GoogleGenerativeAiEmbeddingFunction.import();
-            googleGenAiApi = googleGenAi;
-            // googleGenAiApi.init(this.api_key);
-            googleGenAiApi = new googleGenAiApi(this.api_key);
-        } catch (_a) {
-            // @ts-ignore
-            if (_a.code === 'MODULE_NOT_FOUND') {
-                throw new Error("Please install the @google/generative-ai package to use the GoogleGenerativeAiEmbeddingFunction, `npm install -S @google/generative-ai`");
-            }
-            throw _a; // Re-throw other errors
-        }
-        this.googleGenAiApi = googleGenAiApi;
-    }
-
-    public async generate(texts: string[]) {
-
-        await this.loadClient();
-        const model = this.googleGenAiApi.getGenerativeModel({ model: this.model});
-        const response = await model.batchEmbedContents({
-            requests: texts.map((t) => ({
-              content: { parts: [{ text: t }] },
-              taskType: this.taskType,
-            })),
-          });
-        const embeddings = response.embeddings.map((e: any) => e.values);
-
-        return embeddings;
-    }
-
-    /** @ignore */
-    static async import(): Promise<{
-        // @ts-ignore
-        googleGenAi: typeof import("@google/generative-ai");
-    }> {
-        try {
-            // @ts-ignore
-            const { GoogleGenerativeAI } = await import("@google/generative-ai");
-            const googleGenAi = GoogleGenerativeAI;
-            return { googleGenAi };
-        } catch (e) {
-            throw new Error(
-                "Please install @google/generative-ai as a dependency with, e.g. `yarn add @google/generative-ai`"
-            );
-        }
-    }
-
-}

package/src/embeddings/HuggingFaceEmbeddingServerFunction.ts

@@ -1,31 +0,0 @@
-import { IEmbeddingFunction } from "./IEmbeddingFunction";
-
-let CohereAiApi: any;
-
-export class HuggingFaceEmbeddingServerFunction implements IEmbeddingFunction {
-    private url: string;
-
-    constructor({ url }: { url: string }) {
-        // we used to construct the client here, but we need to async import the types
-        // for the openai npm package, and the constructor can not be async
-        this.url = url;
-    }
-
-    public async generate(texts: string[]) {
-        const response = await fetch(this.url, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json'
-            },
-            body: JSON.stringify({ 'inputs': texts })
-        });
-
-        if (!response.ok) {
-            throw new Error(`Failed to generate embeddings: ${response.statusText}`);
-        }
-
-        const data = await response.json();
-        return data;
-    }
-
-}

package/src/embeddings/JinaEmbeddingFunction.ts

@@ -1,46 +0,0 @@
-import { IEmbeddingFunction } from "./IEmbeddingFunction";
-
-export class JinaEmbeddingFunction implements IEmbeddingFunction {
-  private model_name: string;
-  private api_url: string;
-  private headers: { [key: string]: string };
-
-  constructor({ jinaai_api_key, model_name }: { jinaai_api_key: string; model_name?: string }) {
-    this.model_name = model_name || 'jina-embeddings-v2-base-en';
-    this.api_url = 'https://api.jina.ai/v1/embeddings';
-    this.headers = {
-      Authorization: `Bearer ${jinaai_api_key}`,
-      'Accept-Encoding': 'identity',
-      'Content-Type': 'application/json',
-    };
-  }
-
-  public async generate(texts: string[]) {
-    try {
-      const response = await fetch(this.api_url, {
-        method: 'POST',
-        headers: this.headers,
-        body: JSON.stringify({
-          input: texts,
-          model: this.model_name,
-        }),
-      });
-
-      const data = (await response.json()) as { data: any[]; detail: string };
-      if (!data || !data.data) {
-        throw new Error(data.detail);
-      }
-
-      const embeddings: any[] = data.data;
-      const sortedEmbeddings = embeddings.sort((a, b) => a.index - b.index);
-
-      return sortedEmbeddings.map((result) => result.embedding);
-    } catch (error) {
-      if (error instanceof Error) {
-        throw new Error(`Error calling Jina AI API: ${error.message}`);
-      } else {
-        throw new Error(`Error calling Jina AI API: ${error}`);
-      }
-    }
-  }
-}