langchain 0.0.131 → 0.0.132

package/dist/vectorstores/lancedb.js

@@ -1,5 +1,10 @@
 import { VectorStore } from "./base.js";
 import { Document } from "../document.js";
+/**
+ * A wrapper for an open-source database for vector-search with persistent
+ * storage. It simplifies retrieval, filtering, and management of
+ * embeddings.
+ */
 export class LanceDB extends VectorStore {
     constructor(embeddings, args) {
         super(embeddings, args);
@@ -19,6 +24,11 @@ export class LanceDB extends VectorStore {
         this.embeddings = embeddings;
         this.textKey = args.textKey || "text";
     }
+    /**
+     * Adds documents to the database.
+     * @param documents The documents to be added.
+     * @returns A Promise that resolves when the documents have been added.
+     */
     async addDocuments(documents) {
         const texts = documents.map(({ pageContent }) => pageContent);
         return this.addVectors(await this.embeddings.embedDocuments(texts), documents);
@@ -26,6 +36,12 @@ export class LanceDB extends VectorStore {
     _vectorstoreType() {
         return "lancedb";
     }
+    /**
+     * Adds vectors and their corresponding documents to the database.
+     * @param vectors The vectors to be added.
+     * @param documents The corresponding documents to be added.
+     * @returns A Promise that resolves when the vectors and documents have been added.
+     */
     async addVectors(vectors, documents) {
         if (vectors.length === 0) {
             return;
@@ -46,6 +62,13 @@ export class LanceDB extends VectorStore {
         }
         await this.table.add(data);
     }
+    /**
+     * Performs a similarity search on the vectors in the database and returns
+     * the documents and their scores.
+     * @param query The query vector.
+     * @param k The number of results to return.
+     * @returns A Promise that resolves with an array of tuples, each containing a Document and its score.
+     */
     async similaritySearchVectorWithScore(query, k) {
         const results = await this.table.search(query).limit(k).execute();
         const docsAndScore = [];
@@ -66,6 +89,14 @@ export class LanceDB extends VectorStore {
         });
         return docsAndScore;
     }
+    /**
+     * Creates a new instance of LanceDB from texts.
+     * @param texts The texts to be converted into documents.
+     * @param metadatas The metadata for the texts.
+     * @param embeddings The embeddings to be managed.
+     * @param dbConfig The configuration for the LanceDB instance.
+     * @returns A Promise that resolves with a new instance of LanceDB.
+     */
     static async fromTexts(texts, metadatas, embeddings, dbConfig) {
         const docs = [];
         for (let i = 0; i < texts.length; i += 1) {
@@ -78,6 +109,13 @@ export class LanceDB extends VectorStore {
         }
         return LanceDB.fromDocuments(docs, embeddings, dbConfig);
     }
+    /**
+     * Creates a new instance of LanceDB from documents.
+     * @param docs The documents to be added to the database.
+     * @param embeddings The embeddings to be managed.
+     * @param dbConfig The configuration for the LanceDB instance.
+     * @returns A Promise that resolves with a new instance of LanceDB.
+     */
     static async fromDocuments(docs, embeddings, dbConfig) {
         const instance = new this(embeddings, dbConfig);
         await instance.addDocuments(docs);

package/dist/vectorstores/memory.cjs

@@ -4,6 +4,11 @@ exports.MemoryVectorStore = void 0;
 const ml_distance_1 = require("ml-distance");
 const base_js_1 = require("./base.cjs");
 const document_js_1 = require("../document.cjs");
+/**
+ * Class that extends `VectorStore` to store vectors in memory. Provides
+ * methods for adding documents, performing similarity searches, and
+ * creating instances from texts, documents, or an existing index.
+ */
 class MemoryVectorStore extends base_js_1.VectorStore {
     _vectorstoreType() {
         return "memory";
@@ -24,10 +29,25 @@ class MemoryVectorStore extends base_js_1.VectorStore {
         });
         this.similarity = similarity ?? ml_distance_1.similarity.cosine;
     }
+    /**
+     * Method to add documents to the memory vector store. It extracts the
+     * text from each document, generates embeddings for them, and adds the
+     * resulting vectors to the store.
+     * @param documents Array of `Document` instances to be added to the store.
+     * @returns Promise that resolves when all documents have been added.
+     */
     async addDocuments(documents) {
         const texts = documents.map(({ pageContent }) => pageContent);
         return this.addVectors(await this.embeddings.embedDocuments(texts), documents);
     }
+    /**
+     * Method to add vectors to the memory vector store. It creates
+     * `MemoryVector` instances for each vector and document pair and adds
+     * them to the store.
+     * @param vectors Array of vectors to be added to the store.
+     * @param documents Array of `Document` instances corresponding to the vectors.
+     * @returns Promise that resolves when all vectors have been added.
+     */
     async addVectors(vectors, documents) {
         const memoryVectors = vectors.map((embedding, idx) => ({
             content: documents[idx].pageContent,
@@ -36,6 +56,16 @@ class MemoryVectorStore extends base_js_1.VectorStore {
         }));
         this.memoryVectors = this.memoryVectors.concat(memoryVectors);
     }
+    /**
+     * Method to perform a similarity search in the memory vector store. It
+     * calculates the similarity between the query vector and each vector in
+     * the store, sorts the results by similarity, and returns the top `k`
+     * results along with their scores.
+     * @param query Query vector to compare against the vectors in the store.
+     * @param k Number of top results to return.
+     * @param filter Optional filter function to apply to the vectors before performing the search.
+     * @returns Promise that resolves with an array of tuples, each containing a `Document` and its similarity score.
+     */
     async similaritySearchVectorWithScore(query, k, filter) {
         const filterFunction = (memoryVector) => {
             if (!filter) {
@@ -64,6 +94,16 @@ class MemoryVectorStore extends base_js_1.VectorStore {
         ]);
         return result;
     }
+    /**
+     * Static method to create a `MemoryVectorStore` instance from an array of
+     * texts. It creates a `Document` for each text and metadata pair, and
+     * adds them to the store.
+     * @param texts Array of texts to be added to the store.
+     * @param metadatas Array or single object of metadata corresponding to the texts.
+     * @param embeddings `Embeddings` instance used to generate embeddings for the texts.
+     * @param dbConfig Optional `MemoryVectorStoreArgs` to configure the `MemoryVectorStore` instance.
+     * @returns Promise that resolves with a new `MemoryVectorStore` instance.
+     */
     static async fromTexts(texts, metadatas, embeddings, dbConfig) {
         const docs = [];
         for (let i = 0; i < texts.length; i += 1) {
@@ -76,11 +116,27 @@ class MemoryVectorStore extends base_js_1.VectorStore {
         }
         return MemoryVectorStore.fromDocuments(docs, embeddings, dbConfig);
     }
+    /**
+     * Static method to create a `MemoryVectorStore` instance from an array of
+     * `Document` instances. It adds the documents to the store.
+     * @param docs Array of `Document` instances to be added to the store.
+     * @param embeddings `Embeddings` instance used to generate embeddings for the documents.
+     * @param dbConfig Optional `MemoryVectorStoreArgs` to configure the `MemoryVectorStore` instance.
+     * @returns Promise that resolves with a new `MemoryVectorStore` instance.
+     */
     static async fromDocuments(docs, embeddings, dbConfig) {
         const instance = new this(embeddings, dbConfig);
         await instance.addDocuments(docs);
         return instance;
     }
+    /**
+     * Static method to create a `MemoryVectorStore` instance from an existing
+     * index. It creates a new `MemoryVectorStore` instance without adding any
+     * documents or vectors.
+     * @param embeddings `Embeddings` instance used to generate embeddings for the documents.
+     * @param dbConfig Optional `MemoryVectorStoreArgs` to configure the `MemoryVectorStore` instance.
+     * @returns Promise that resolves with a new `MemoryVectorStore` instance.
+     */
     static async fromExistingIndex(embeddings, dbConfig) {
         const instance = new this(embeddings, dbConfig);
         return instance;

package/dist/vectorstores/memory.d.ts

@@ -2,25 +2,91 @@ import { similarity as ml_distance_similarity } from "ml-distance";
 import { VectorStore } from "./base.js";
 import { Embeddings } from "../embeddings/base.js";
 import { Document } from "../document.js";
+/**
+ * Interface representing a vector in memory. It includes the content
+ * (text), the corresponding embedding (vector), and any associated
+ * metadata.
+ */
 interface MemoryVector {
     content: string;
     embedding: number[];
     metadata: Record<string, any>;
 }
+/**
+ * Interface for the arguments that can be passed to the
+ * `MemoryVectorStore` constructor. It includes an optional `similarity`
+ * function.
+ */
 export interface MemoryVectorStoreArgs {
     similarity?: typeof ml_distance_similarity.cosine;
 }
+/**
+ * Class that extends `VectorStore` to store vectors in memory. Provides
+ * methods for adding documents, performing similarity searches, and
+ * creating instances from texts, documents, or an existing index.
+ */
 export declare class MemoryVectorStore extends VectorStore {
     FilterType: (doc: Document) => boolean;
     memoryVectors: MemoryVector[];
     similarity: typeof ml_distance_similarity.cosine;
     _vectorstoreType(): string;
     constructor(embeddings: Embeddings, { similarity, ...rest }?: MemoryVectorStoreArgs);
+    /**
+     * Method to add documents to the memory vector store. It extracts the
+     * text from each document, generates embeddings for them, and adds the
+     * resulting vectors to the store.
+     * @param documents Array of `Document` instances to be added to the store.
+     * @returns Promise that resolves when all documents have been added.
+     */
     addDocuments(documents: Document[]): Promise<void>;
+    /**
+     * Method to add vectors to the memory vector store. It creates
+     * `MemoryVector` instances for each vector and document pair and adds
+     * them to the store.
+     * @param vectors Array of vectors to be added to the store.
+     * @param documents Array of `Document` instances corresponding to the vectors.
+     * @returns Promise that resolves when all vectors have been added.
+     */
     addVectors(vectors: number[][], documents: Document[]): Promise<void>;
+    /**
+     * Method to perform a similarity search in the memory vector store. It
+     * calculates the similarity between the query vector and each vector in
+     * the store, sorts the results by similarity, and returns the top `k`
+     * results along with their scores.
+     * @param query Query vector to compare against the vectors in the store.
+     * @param k Number of top results to return.
+     * @param filter Optional filter function to apply to the vectors before performing the search.
+     * @returns Promise that resolves with an array of tuples, each containing a `Document` and its similarity score.
+     */
     similaritySearchVectorWithScore(query: number[], k: number, filter?: this["FilterType"]): Promise<[Document, number][]>;
+    /**
+     * Static method to create a `MemoryVectorStore` instance from an array of
+     * texts. It creates a `Document` for each text and metadata pair, and
+     * adds them to the store.
+     * @param texts Array of texts to be added to the store.
+     * @param metadatas Array or single object of metadata corresponding to the texts.
+     * @param embeddings `Embeddings` instance used to generate embeddings for the texts.
+     * @param dbConfig Optional `MemoryVectorStoreArgs` to configure the `MemoryVectorStore` instance.
+     * @returns Promise that resolves with a new `MemoryVectorStore` instance.
+     */
     static fromTexts(texts: string[], metadatas: object[] | object, embeddings: Embeddings, dbConfig?: MemoryVectorStoreArgs): Promise<MemoryVectorStore>;
+    /**
+     * Static method to create a `MemoryVectorStore` instance from an array of
+     * `Document` instances. It adds the documents to the store.
+     * @param docs Array of `Document` instances to be added to the store.
+     * @param embeddings `Embeddings` instance used to generate embeddings for the documents.
+     * @param dbConfig Optional `MemoryVectorStoreArgs` to configure the `MemoryVectorStore` instance.
+     * @returns Promise that resolves with a new `MemoryVectorStore` instance.
+     */
     static fromDocuments(docs: Document[], embeddings: Embeddings, dbConfig?: MemoryVectorStoreArgs): Promise<MemoryVectorStore>;
+    /**
+     * Static method to create a `MemoryVectorStore` instance from an existing
+     * index. It creates a new `MemoryVectorStore` instance without adding any
+     * documents or vectors.
+     * @param embeddings `Embeddings` instance used to generate embeddings for the documents.
+     * @param dbConfig Optional `MemoryVectorStoreArgs` to configure the `MemoryVectorStore` instance.
+     * @returns Promise that resolves with a new `MemoryVectorStore` instance.
+     */
     static fromExistingIndex(embeddings: Embeddings, dbConfig?: MemoryVectorStoreArgs): Promise<MemoryVectorStore>;
 }
 export {};

package/dist/vectorstores/memory.js

@@ -1,6 +1,11 @@
 import { similarity as ml_distance_similarity } from "ml-distance";
 import { VectorStore } from "./base.js";
 import { Document } from "../document.js";
+/**
+ * Class that extends `VectorStore` to store vectors in memory. Provides
+ * methods for adding documents, performing similarity searches, and
+ * creating instances from texts, documents, or an existing index.
+ */
 export class MemoryVectorStore extends VectorStore {
     _vectorstoreType() {
         return "memory";
@@ -21,10 +26,25 @@ export class MemoryVectorStore extends VectorStore {
         });
         this.similarity = similarity ?? ml_distance_similarity.cosine;
     }
+    /**
+     * Method to add documents to the memory vector store. It extracts the
+     * text from each document, generates embeddings for them, and adds the
+     * resulting vectors to the store.
+     * @param documents Array of `Document` instances to be added to the store.
+     * @returns Promise that resolves when all documents have been added.
+     */
     async addDocuments(documents) {
         const texts = documents.map(({ pageContent }) => pageContent);
         return this.addVectors(await this.embeddings.embedDocuments(texts), documents);
     }
+    /**
+     * Method to add vectors to the memory vector store. It creates
+     * `MemoryVector` instances for each vector and document pair and adds
+     * them to the store.
+     * @param vectors Array of vectors to be added to the store.
+     * @param documents Array of `Document` instances corresponding to the vectors.
+     * @returns Promise that resolves when all vectors have been added.
+     */
     async addVectors(vectors, documents) {
         const memoryVectors = vectors.map((embedding, idx) => ({
             content: documents[idx].pageContent,
@@ -33,6 +53,16 @@ export class MemoryVectorStore extends VectorStore {
         }));
         this.memoryVectors = this.memoryVectors.concat(memoryVectors);
     }
+    /**
+     * Method to perform a similarity search in the memory vector store. It
+     * calculates the similarity between the query vector and each vector in
+     * the store, sorts the results by similarity, and returns the top `k`
+     * results along with their scores.
+     * @param query Query vector to compare against the vectors in the store.
+     * @param k Number of top results to return.
+     * @param filter Optional filter function to apply to the vectors before performing the search.
+     * @returns Promise that resolves with an array of tuples, each containing a `Document` and its similarity score.
+     */
     async similaritySearchVectorWithScore(query, k, filter) {
         const filterFunction = (memoryVector) => {
             if (!filter) {
@@ -61,6 +91,16 @@ export class MemoryVectorStore extends VectorStore {
         ]);
         return result;
     }
+    /**
+     * Static method to create a `MemoryVectorStore` instance from an array of
+     * texts. It creates a `Document` for each text and metadata pair, and
+     * adds them to the store.
+     * @param texts Array of texts to be added to the store.
+     * @param metadatas Array or single object of metadata corresponding to the texts.
+     * @param embeddings `Embeddings` instance used to generate embeddings for the texts.
+     * @param dbConfig Optional `MemoryVectorStoreArgs` to configure the `MemoryVectorStore` instance.
+     * @returns Promise that resolves with a new `MemoryVectorStore` instance.
+     */
     static async fromTexts(texts, metadatas, embeddings, dbConfig) {
         const docs = [];
         for (let i = 0; i < texts.length; i += 1) {
@@ -73,11 +113,27 @@ export class MemoryVectorStore extends VectorStore {
         }
         return MemoryVectorStore.fromDocuments(docs, embeddings, dbConfig);
     }
+    /**
+     * Static method to create a `MemoryVectorStore` instance from an array of
+     * `Document` instances. It adds the documents to the store.
+     * @param docs Array of `Document` instances to be added to the store.
+     * @param embeddings `Embeddings` instance used to generate embeddings for the documents.
+     * @param dbConfig Optional `MemoryVectorStoreArgs` to configure the `MemoryVectorStore` instance.
+     * @returns Promise that resolves with a new `MemoryVectorStore` instance.
+     */
     static async fromDocuments(docs, embeddings, dbConfig) {
         const instance = new this(embeddings, dbConfig);
         await instance.addDocuments(docs);
         return instance;
     }
+    /**
+     * Static method to create a `MemoryVectorStore` instance from an existing
+     * index. It creates a new `MemoryVectorStore` instance without adding any
+     * documents or vectors.
+     * @param embeddings `Embeddings` instance used to generate embeddings for the documents.
+     * @param dbConfig Optional `MemoryVectorStoreArgs` to configure the `MemoryVectorStore` instance.
+     * @returns Promise that resolves with a new `MemoryVectorStore` instance.
+     */
     static async fromExistingIndex(embeddings, dbConfig) {
         const instance = new this(embeddings, dbConfig);
         return instance;

package/dist/vectorstores/milvus.cjs

@@ -33,6 +33,10 @@ const MILVUS_PRIMARY_FIELD_NAME = "langchain_primaryid";
 const MILVUS_VECTOR_FIELD_NAME = "langchain_vector";
 const MILVUS_TEXT_FIELD_NAME = "langchain_text";
 const MILVUS_COLLECTION_NAME_PREFIX = "langchain_col";
+/**
+ * Class for interacting with a Milvus database. Extends the VectorStore
+ * class.
+ */
 class Milvus extends base_js_1.VectorStore {
     get lc_secrets() {
         return {
@@ -135,21 +139,41 @@ class Milvus extends base_js_1.VectorStore {
         this.embeddings = embeddings;
         this.collectionName = args.collectionName ?? genCollectionName();
         this.textField = args.textField ?? MILVUS_TEXT_FIELD_NAME;
-        this.autoId = true;
+        this.autoId = args.autoId ?? true;
         this.primaryField = args.primaryField ?? MILVUS_PRIMARY_FIELD_NAME;
         this.vectorField = args.vectorField ?? MILVUS_VECTOR_FIELD_NAME;
         this.textFieldMaxLength = args.textFieldMaxLength ?? 0;
         this.fields = [];
         const url = args.url ?? (0, env_js_1.getEnvironmentVariable)("MILVUS_URL");
-        if (!url) {
+        const { address = "", username = "", password = "", ssl, } = args.clientConfig || {};
+        // combine args clientConfig and env variables
+        const clientConfig = {
+            ...(args.clientConfig || {}),
+            address: url || address,
+            username: args.username || username,
+            password: args.password || password,
+            ssl: args.ssl || ssl,
+        };
+        if (!clientConfig.address) {
             throw new Error("Milvus URL address is not provided.");
         }
-        this.client = new milvus2_sdk_node_1.MilvusClient(url, args.ssl, args.username, args.password);
+        this.client = new milvus2_sdk_node_1.MilvusClient(clientConfig);
     }
+    /**
+     * Adds documents to the Milvus database.
+     * @param documents Array of Document instances to be added to the database.
+     * @returns Promise resolving to void.
+     */
     async addDocuments(documents) {
         const texts = documents.map(({ pageContent }) => pageContent);
         await this.addVectors(await this.embeddings.embedDocuments(texts), documents);
     }
+    /**
+     * Adds vectors to the Milvus database.
+     * @param vectors Array of vectors to be added to the database.
+     * @param documents Array of Document instances associated with the vectors.
+     * @returns Promise resolving to void.
+     */
     async addVectors(vectors, documents) {
         if (vectors.length === 0) {
             return;
@@ -204,6 +228,14 @@ class Milvus extends base_js_1.VectorStore {
         }
         await this.client.flushSync({ collection_names: [this.collectionName] });
     }
+    /**
+     * Searches for vectors in the Milvus database that are similar to a given
+     * vector.
+     * @param query Vector to compare with the vectors in the database.
+     * @param k Number of similar vectors to return.
+     * @param filter Optional filter to apply to the search.
+     * @returns Promise resolving to an array of tuples, each containing a Document instance and a similarity score.
+     */
     async similaritySearchVectorWithScore(query, k, filter) {
         const hasColResp = await this.client.hasCollection({
             collection_name: this.collectionName,
@@ -266,6 +298,12 @@ class Milvus extends base_js_1.VectorStore {
         // console.log("Search result: " + JSON.stringify(results, null, 2));
         return results;
     }
+    /**
+     * Ensures that a collection exists in the Milvus database.
+     * @param vectors Optional array of vectors to be used if a new collection needs to be created.
+     * @param documents Optional array of Document instances to be used if a new collection needs to be created.
+     * @returns Promise resolving to void.
+     */
     async ensureCollection(vectors, documents) {
         const hasColResp = await this.client.hasCollection({
             collection_name: this.collectionName,
@@ -283,9 +321,15 @@ class Milvus extends base_js_1.VectorStore {
             await this.grabCollectionFields();
         }
     }
+    /**
+     * Creates a collection in the Milvus database.
+     * @param vectors Array of vectors to be added to the new collection.
+     * @param documents Array of Document instances to be added to the new collection.
+     * @returns Promise resolving to void.
+     */
     async createCollection(vectors, documents) {
         const fieldList = [];
-        fieldList.push(...createFieldTypeForMetadata(documents));
+        fieldList.push(...createFieldTypeForMetadata(documents, this.primaryField));
         fieldList.push({
             name: this.primaryField,
             description: "Primary key",
@@ -328,6 +372,10 @@ class Milvus extends base_js_1.VectorStore {
             extra_params: this.indexCreateParams,
         });
     }
+    /**
+     * Retrieves the fields of a collection in the Milvus database.
+     * @returns Promise resolving to void.
+     */
     async grabCollectionFields() {
         if (!this.collectionName) {
             throw new Error("Need collection name to grab collection fields");
@@ -352,7 +400,7 @@ class Milvus extends base_js_1.VectorStore {
             if (field.is_primary_key) {
                 this.primaryField = field.name;
             }
-            const dtype = milvus2_sdk_node_1.DataTypeMap[field.data_type.toLowerCase()];
+            const dtype = milvus2_sdk_node_1.DataTypeMap[field.data_type];
             if (dtype === milvus2_sdk_node_1.DataType.FloatVector || dtype === milvus2_sdk_node_1.DataType.BinaryVector) {
                 this.vectorField = field.name;
             }
@@ -361,6 +409,15 @@ class Milvus extends base_js_1.VectorStore {
             }
         });
     }
+    /**
+     * Creates a Milvus instance from a set of texts and their associated
+     * metadata.
+     * @param texts Array of texts to be added to the database.
+     * @param metadatas Array of metadata objects associated with the texts.
+     * @param embeddings Embeddings instance used to generate vector embeddings for the texts.
+     * @param dbConfig Optional configuration for the Milvus database.
+     * @returns Promise resolving to a new Milvus instance.
+     */
     static async fromTexts(texts, metadatas, embeddings, dbConfig) {
         const docs = [];
         for (let i = 0; i < texts.length; i += 1) {
@@ -373,6 +430,13 @@ class Milvus extends base_js_1.VectorStore {
         }
         return Milvus.fromDocuments(docs, embeddings, dbConfig);
     }
+    /**
+     * Creates a Milvus instance from a set of Document instances.
+     * @param docs Array of Document instances to be added to the database.
+     * @param embeddings Embeddings instance used to generate vector embeddings for the documents.
+     * @param dbConfig Optional configuration for the Milvus database.
+     * @returns Promise resolving to a new Milvus instance.
+     */
     static async fromDocuments(docs, embeddings, dbConfig) {
         const args = {
             collectionName: dbConfig?.collectionName || genCollectionName(),
@@ -383,16 +447,30 @@ class Milvus extends base_js_1.VectorStore {
             textField: dbConfig?.textField,
             primaryField: dbConfig?.primaryField,
             vectorField: dbConfig?.vectorField,
+            clientConfig: dbConfig?.clientConfig,
+            autoId: dbConfig?.autoId,
         };
         const instance = new this(embeddings, args);
         await instance.addDocuments(docs);
         return instance;
     }
+    /**
+     * Creates a Milvus instance from an existing collection in the Milvus
+     * database.
+     * @param embeddings Embeddings instance used to generate vector embeddings for the documents in the collection.
+     * @param dbConfig Configuration for the Milvus database.
+     * @returns Promise resolving to a new Milvus instance.
+     */
     static async fromExistingCollection(embeddings, dbConfig) {
         const instance = new this(embeddings, dbConfig);
         await instance.ensureCollection();
         return instance;
     }
+    /**
+     * Deletes data from the Milvus database.
+     * @param params Object containing a filter to apply to the deletion.
+     * @returns Promise resolving to void.
+     */
     async delete(params) {
         const hasColResp = await this.client.hasCollection({
             collection_name: this.collectionName,
@@ -414,7 +492,7 @@ class Milvus extends base_js_1.VectorStore {
     }
 }
 exports.Milvus = Milvus;
-function createFieldTypeForMetadata(documents) {
+function createFieldTypeForMetadata(documents, primaryFieldName) {
     const sampleMetadata = documents[0].metadata;
     let textFieldMaxLength = 0;
     let jsonFieldMaxLength = 0;
@@ -442,7 +520,13 @@ function createFieldTypeForMetadata(documents) {
     const fields = [];
     for (const [key, value] of Object.entries(sampleMetadata)) {
         const type = typeof value;
-        if (type === "string") {
+        if (key === primaryFieldName) {
+            /**
+             * skip primary field
+             * because we will create primary field in createCollection
+             *  */
+        }
+        else if (type === "string") {
             fields.push({
                 name: key,
                 description: `Metadata String field`,