langchain 0.0.196 → 0.0.197-rc.1

package/dist/vectorstores/mongodb_atlas.d.ts

@@ -101,5 +101,18 @@ export declare class MongoDBAtlasVectorSearch extends VectorStore {
      * @returns Promise that resolves to a new instance of MongoDBAtlasVectorSearch.
      */
     static fromDocuments(docs: Document[], embeddings: Embeddings, dbConfig: MongoDBAtlasVectorSearchLibArgs): Promise<MongoDBAtlasVectorSearch>;
+    /**
+     * Static method to fix the precision of the array that ensures that
+     * every number in this array is always float when casted to other types.
+     * This is needed since MongoDB Atlas Vector Search does not cast integer
+     * inside vector search to float automatically.
+     * This method shall introduce a hint of error but should be safe to use
+     * since introduced error is very small, only applies to integer numbers
+     * returned by embeddings, and most embeddings shall not have precision
+     * as high as 15 decimal places.
+     * @param array Array of number to be fixed.
+     * @returns
+     */
+    static fixArrayPrecision(array: number[]): number[];
 }
 export {};

package/dist/vectorstores/mongodb_atlas.js

@@ -96,7 +96,7 @@ export class MongoDBAtlasVectorSearch extends VectorStore {
         const pipeline = [
             {
                 $vectorSearch: {
-                    queryVector: query,
+                    queryVector: MongoDBAtlasVectorSearch.fixArrayPrecision(query),
                     index: this.indexName,
                     path: this.embeddingKey,
                     limit: k,
@@ -145,7 +145,7 @@ export class MongoDBAtlasVectorSearch extends VectorStore {
             ...filter,
             includeEmbeddings: true,
         };
-        const resultDocs = await this.similaritySearchVectorWithScore(queryEmbedding, fetchK, includeEmbeddingsFilter);
+        const resultDocs = await this.similaritySearchVectorWithScore(MongoDBAtlasVectorSearch.fixArrayPrecision(queryEmbedding), fetchK, includeEmbeddingsFilter);
         const embeddingList = resultDocs.map((doc) => doc[0].metadata[this.embeddingKey]);
         const mmrIndexes = maximalMarginalRelevance(queryEmbedding, embeddingList, lambda, k);
         return mmrIndexes.map((idx) => {
@@ -193,4 +193,24 @@ export class MongoDBAtlasVectorSearch extends VectorStore {
         await instance.addDocuments(docs);
         return instance;
     }
+    /**
+     * Static method to fix the precision of the array that ensures that
+     * every number in this array is always float when casted to other types.
+     * This is needed since MongoDB Atlas Vector Search does not cast integer
+     * inside vector search to float automatically.
+     * This method shall introduce a hint of error but should be safe to use
+     * since introduced error is very small, only applies to integer numbers
+     * returned by embeddings, and most embeddings shall not have precision
+     * as high as 15 decimal places.
+     * @param array Array of number to be fixed.
+     * @returns
+     */
+    static fixArrayPrecision(array) {
+        return array.map((value) => {
+            if (Number.isInteger(value)) {
+                return value + 0.000000000000001;
+            }
+            return value;
+        });
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "langchain",
-  "version": "0.0.196",
+  "version": "0.0.197-rc.1",
   "description": "Typescript bindings for langchain",
   "type": "module",
   "engines": {
@@ -859,12 +859,15 @@
     "@faker-js/faker": "^7.6.0",
     "@getmetal/metal-sdk": "^4.0.0",
     "@getzep/zep-js": "^0.9.0",
-    "@gomomento/sdk": "^1.47.1",
-    "@gomomento/sdk-core": "^1.47.1",
+    "@gomomento/sdk": "^1.51.1",
+    "@gomomento/sdk-core": "^1.51.1",
     "@google-ai/generativelanguage": "^0.2.1",
     "@google-cloud/storage": "^6.10.1",
     "@huggingface/inference": "^2.6.4",
     "@jest/globals": "^29.5.0",
+    "@langchain/anthropic": "workspace:*",
+    "@langchain/core": "workspace:*",
+    "@langchain/openai": "workspace:*",
     "@mozilla/readability": "^0.4.4",
     "@notionhq/client": "^2.2.10",
     "@opensearch-project/opensearch": "^2.2.0",
@@ -942,7 +945,6 @@
     "jest": "^29.5.0",
     "jest-environment-node": "^29.6.4",
     "jsdom": "^22.1.0",
-    "langchain-core": "workspace:*",
     "llmonitor": "^0.5.9",
     "lodash": "^4.17.21",
     "mammoth": "^1.5.1",
@@ -997,9 +999,9 @@
     "@elastic/elasticsearch": "^8.4.0",
     "@getmetal/metal-sdk": "*",
     "@getzep/zep-js": "^0.9.0",
-    "@gomomento/sdk": "^1.47.1",
-    "@gomomento/sdk-core": "^1.47.1",
-    "@gomomento/sdk-web": "^1.47.1",
+    "@gomomento/sdk": "^1.51.1",
+    "@gomomento/sdk-core": "^1.51.1",
+    "@gomomento/sdk-web": "^1.51.1",
     "@google-ai/generativelanguage": "^0.2.1",
     "@google-cloud/storage": "^6.10.1",
     "@huggingface/inference": "^2.6.4",
@@ -1378,18 +1380,18 @@
     }
   },
   "dependencies": {
-    "@anthropic-ai/sdk": "^0.9.1",
+    "@langchain/anthropic": "^0.0.3",
+    "@langchain/core": "^0.0.1",
+    "@langchain/openai": "^0.0.1",
     "binary-extensions": "^2.2.0",
     "expr-eval": "^2.0.2",
     "flat": "^5.0.2",
     "js-tiktoken": "^1.0.7",
     "js-yaml": "^4.1.0",
     "jsonpointer": "^5.0.1",
-    "langchain-core": "^0.0.1",
     "langchainhub": "~0.0.6",
     "langsmith": "~0.0.48",
     "ml-distance": "^4.0.0",
-    "openai": "^4.19.0",
     "openapi-types": "^12.1.3",
     "p-retry": "4",
     "uuid": "^9.0.0",

package/dist/util/openai-format-fndef.cjs

@@ -1,81 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.formatFunctionDefinitions = void 0;
-function isAnyOfProp(prop) {
-    return (prop.anyOf !== undefined &&
-        Array.isArray(prop.anyOf));
-}
-// When OpenAI use functions in the prompt, they format them as TypeScript definitions rather than OpenAPI JSON schemas.
-// This function converts the JSON schemas into TypeScript definitions.
-function formatFunctionDefinitions(functions) {
-    const lines = ["namespace functions {", ""];
-    for (const f of functions) {
-        if (f.description) {
-            lines.push(`// ${f.description}`);
-        }
-        if (Object.keys(f.parameters.properties ?? {}).length > 0) {
-            lines.push(`type ${f.name} = (_: {`);
-            lines.push(formatObjectProperties(f.parameters, 0));
-            lines.push("}) => any;");
-        }
-        else {
-            lines.push(`type ${f.name} = () => any;`);
-        }
-        lines.push("");
-    }
-    lines.push("} // namespace functions");
-    return lines.join("\n");
-}
-exports.formatFunctionDefinitions = formatFunctionDefinitions;
-// Format just the properties of an object (not including the surrounding braces)
-function formatObjectProperties(obj, indent) {
-    const lines = [];
-    for (const [name, param] of Object.entries(obj.properties ?? {})) {
-        if (param.description && indent < 2) {
-            lines.push(`// ${param.description}`);
-        }
-        if (obj.required?.includes(name)) {
-            lines.push(`${name}: ${formatType(param, indent)},`);
-        }
-        else {
-            lines.push(`${name}?: ${formatType(param, indent)},`);
-        }
-    }
-    return lines.map((line) => " ".repeat(indent) + line).join("\n");
-}
-// Format a single property type
-function formatType(param, indent) {
-    if (isAnyOfProp(param)) {
-        return param.anyOf.map((v) => formatType(v, indent)).join(" | ");
-    }
-    switch (param.type) {
-        case "string":
-            if (param.enum) {
-                return param.enum.map((v) => `"${v}"`).join(" | ");
-            }
-            return "string";
-        case "number":
-            if (param.enum) {
-                return param.enum.map((v) => `${v}`).join(" | ");
-            }
-            return "number";
-        case "integer":
-            if (param.enum) {
-                return param.enum.map((v) => `${v}`).join(" | ");
-            }
-            return "number";
-        case "boolean":
-            return "boolean";
-        case "null":
-            return "null";
-        case "object":
-            return ["{", formatObjectProperties(param, indent + 2), "}"].join("\n");
-        case "array":
-            if (param.items) {
-                return `${formatType(param.items, indent)}[]`;
-            }
-            return "any[]";
-        default:
-            return "";
-    }
-}

package/dist/util/openai-format-fndef.d.ts

@@ -1,44 +0,0 @@
-/**
- * Formatting function definitions for calculating openai function defination token usage.
- *
- * https://github.com/hmarr/openai-chat-tokens/blob/main/src/functions.ts
- * (c) 2023 Harry Marr
- * MIT license
- */
-import OpenAI from "openai";
-type OpenAIFunction = OpenAI.Chat.ChatCompletionCreateParams.Function;
-export interface FunctionDef extends Omit<OpenAIFunction, "parameters"> {
-    name: string;
-    description?: string;
-    parameters: ObjectProp;
-}
-interface ObjectProp {
-    type: "object";
-    properties?: {
-        [key: string]: Prop;
-    };
-    required?: string[];
-}
-interface AnyOfProp {
-    anyOf: Prop[];
-}
-type Prop = {
-    description?: string;
-} & (AnyOfProp | ObjectProp | {
-    type: "string";
-    enum?: string[];
-} | {
-    type: "number" | "integer";
-    minimum?: number;
-    maximum?: number;
-    enum?: number[];
-} | {
-    type: "boolean";
-} | {
-    type: "null";
-} | {
-    type: "array";
-    items?: Prop;
-});
-export declare function formatFunctionDefinitions(functions: FunctionDef[]): string;
-export {};

package/dist/util/openai-format-fndef.js

@@ -1,77 +0,0 @@
-function isAnyOfProp(prop) {
-    return (prop.anyOf !== undefined &&
-        Array.isArray(prop.anyOf));
-}
-// When OpenAI use functions in the prompt, they format them as TypeScript definitions rather than OpenAPI JSON schemas.
-// This function converts the JSON schemas into TypeScript definitions.
-export function formatFunctionDefinitions(functions) {
-    const lines = ["namespace functions {", ""];
-    for (const f of functions) {
-        if (f.description) {
-            lines.push(`// ${f.description}`);
-        }
-        if (Object.keys(f.parameters.properties ?? {}).length > 0) {
-            lines.push(`type ${f.name} = (_: {`);
-            lines.push(formatObjectProperties(f.parameters, 0));
-            lines.push("}) => any;");
-        }
-        else {
-            lines.push(`type ${f.name} = () => any;`);
-        }
-        lines.push("");
-    }
-    lines.push("} // namespace functions");
-    return lines.join("\n");
-}
-// Format just the properties of an object (not including the surrounding braces)
-function formatObjectProperties(obj, indent) {
-    const lines = [];
-    for (const [name, param] of Object.entries(obj.properties ?? {})) {
-        if (param.description && indent < 2) {
-            lines.push(`// ${param.description}`);
-        }
-        if (obj.required?.includes(name)) {
-            lines.push(`${name}: ${formatType(param, indent)},`);
-        }
-        else {
-            lines.push(`${name}?: ${formatType(param, indent)},`);
-        }
-    }
-    return lines.map((line) => " ".repeat(indent) + line).join("\n");
-}
-// Format a single property type
-function formatType(param, indent) {
-    if (isAnyOfProp(param)) {
-        return param.anyOf.map((v) => formatType(v, indent)).join(" | ");
-    }
-    switch (param.type) {
-        case "string":
-            if (param.enum) {
-                return param.enum.map((v) => `"${v}"`).join(" | ");
-            }
-            return "string";
-        case "number":
-            if (param.enum) {
-                return param.enum.map((v) => `${v}`).join(" | ");
-            }
-            return "number";
-        case "integer":
-            if (param.enum) {
-                return param.enum.map((v) => `${v}`).join(" | ");
-            }
-            return "number";
-        case "boolean":
-            return "boolean";
-        case "null":
-            return "null";
-        case "object":
-            return ["{", formatObjectProperties(param, indent + 2), "}"].join("\n");
-        case "array":
-            if (param.items) {
-                return `${formatType(param.items, indent)}[]`;
-            }
-            return "any[]";
-        default:
-            return "";
-    }
-}