Enable support for Browsers, Cloudflare Workers, Next.js Browser/Serverless/Edge

.github/workflows/ci.yml

@@ -1,7 +1,7 @@
 # This workflow will do a clean installation of node dependencies, cache/restore them, build the source code and run tests across different versions of node
 # For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-nodejs
 
-name: Node.js CI
+name: CI
 
 on:
   push:
@@ -55,7 +55,7 @@ jobs:
         run: yarn run build
 
   test:
-    name: Test
+    name: Unit Tests
     strategy:
       matrix:
         os: [macos-latest, windows-latest, ubuntu-latest]
@@ -75,3 +75,20 @@ jobs:
         run: yarn run build --filter="!docs"
       - name: Test
         run: yarn run test:unit
+
+  test-exports:
+    name: Environment Tests
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - name: Use Node.js 18.x
+        uses: actions/setup-node@v3
+        with:
+          node-version: 18.x
+          cache: "yarn"
+      - name: Install dependencies
+        run: yarn install --immutable
+      - name: Build
+        run: yarn run build --filter="!docs"
+      - name: Test Exports
+        run: yarn run test:exports:docker

.vscode/settings.json

@@ -3,8 +3,10 @@
     "./langchain",
     "./examples",
     "./docs",
+    "./test-exports-vercel",
+    "./test-exports-cra",
   ],
   "yaml.schemas": {
     "https://json.schemastore.org/github-workflow.json": "./.github/workflows/deploy.yml"
   }
-}
+}

CONTRIBUTING.md

@@ -162,6 +162,14 @@ To run only integration tests, run:
 yarn test:int
 ```
 
+**Environment tests** test whether LangChain works across different JS environments, including Node.js (both ESM and CJS), Edge environments (eg. Cloudflare Workers), and browsers (using Webpack).
+
+To run the environment tests with Docker run:
+
+```bash
+yarn test:exports:docker
+```
+
 ### Building
 
 To build the project, run:
@@ -183,21 +191,23 @@ level of the repo.
 
 ### Adding an Entrypoint
 
-Langchain exposes multiple multiple subpaths the user can import from, e.g.
+LangChain exposes multiple subpaths the user can import from, e.g.
 
 ```ts
-import { OpenAI } from "langchain/llms";
+import { OpenAI } from "langchain/llms/openai";
 ```
 
+We call these subpaths "entrypoints". In general, you should create a new entrypoint if you are adding a new integration with a 3rd party library. If you're adding self-contained functionality without any external dependencies, you can add it to an existing entrypoint.
+
 In order to declare a new entrypoint that users can import from, you
-should edit the `langchain/create-entrypoints.js` script. To add an
-entrypoint `tools` that imports from `agents/tools/index.ts` you could add
+should edit the `langchain/scripts/create-entrypoints.js` script. To add an
+entrypoint `tools` that imports from `tools/index.ts` you'd add
 the following to the `entrypoints` variable:
 
 ```ts
 const entrypoints = {
   // ...
-  tools: "agents/tools/index.ts",
+  tools: "tools/index",
 };
 ```
 

README.md

@@ -12,7 +12,7 @@ Please fill out [this form](https://forms.gle/57d8AmXBYp8PP8tZA) and we'll set u
 `yarn add langchain`
 
 ```typescript
-import { OpenAI } from "langchain/llms";
+import { OpenAI } from "langchain/llms/openai";
 ```
 
 ## 🤔 What is this?

docker-compose.yml

@@ -0,0 +1,56 @@
+version: '3'
+services:
+  test-exports-esm:
+    image: node:18
+    working_dir: /app
+    volumes:
+      - ./test-exports-esm:/package
+      - ./langchain:/langchain
+      - ./scripts:/scripts
+    command: bash /scripts/docker-ci-entrypoint.sh
+  test-exports-cjs:
+    image: node:18
+    working_dir: /app
+    volumes:
+      - ./test-exports-cjs:/package
+      - ./langchain:/langchain
+      - ./scripts:/scripts
+    command: bash /scripts/docker-ci-entrypoint.sh
+  test-exports-cra:
+    image: node:18
+    working_dir: /app
+    volumes:
+      - ./test-exports-cra:/package
+      - ./langchain:/langchain
+      - ./scripts:/scripts
+    command: bash /scripts/docker-ci-entrypoint.sh
+  test-exports-cf:
+    image: node:18
+    working_dir: /app
+    volumes:
+      - ./test-exports-cf:/package
+      - ./langchain:/langchain
+      - ./scripts:/scripts
+    command: bash /scripts/docker-ci-entrypoint.sh
+  test-exports-vercel:
+    image: node:18
+    working_dir: /app
+    volumes:
+      - ./test-exports-vercel:/package
+      - ./langchain:/langchain
+      - ./scripts:/scripts
+    command: bash /scripts/docker-ci-entrypoint.sh
+  success:
+    image: alpine:3.14
+    command: echo "Success"
+    depends_on:
+      test-exports-esm:
+        condition: service_completed_successfully
+      test-exports-cjs:
+        condition: service_completed_successfully
+      test-exports-cra:
+        condition: service_completed_successfully
+      test-exports-cf:
+        condition: service_completed_successfully
+      test-exports-vercel:
+        condition: service_completed_successfully

docs/docs/getting-started/guide-chat.mdx

@@ -22,7 +22,7 @@ To get started, follow the [installation instructions](./install) to install Lan
 This section covers how to get started with chat models. The interface is based around messages rather than raw text.
 
 ```typescript
-import { ChatOpenAI } from "langchain/chat_models";
+import { ChatOpenAI } from "langchain/chat_models/openai";
 import { HumanChatMessage, SystemChatMessage } from "langchain/schema";
 
 const chat = new ChatOpenAI({ temperature: 0 });

docs/docs/getting-started/guide-llm.mdx

@@ -32,7 +32,7 @@ The most basic building block of LangChain is calling an LLM on some input. Let'
 In order to do this, we first need to import the LLM wrapper.
 
 ```typescript
-import { OpenAI } from "langchain";
+import { OpenAI } from "langchain/llms/openai";
 ```
 
 We will then need to set the environment variable for the OpenAI key. Three options here:
@@ -110,7 +110,7 @@ The most core type of chain is an LLMChain, which consists of a PromptTemplate a
 Extending the previous example, we can construct an LLMChain which takes user input, formats it with a PromptTemplate, and then passes the formatted response to an LLM.
 
 ```typescript
-import { OpenAI } from "langchain/llms";
+import { OpenAI } from "langchain/llms/openai";
 import { PromptTemplate } from "langchain/prompts";
 
 const model = new OpenAI({ temperature: 0.9 });
@@ -165,9 +165,10 @@ SERPAPI_API_KEY="..."
 Now we can get started!
 
 ```typescript
-import { OpenAI } from "langchain";
+import { OpenAI } from "langchain/llms/openai";
 import { initializeAgentExecutor } from "langchain/agents";
-import { SerpAPI, Calculator } from "langchain/tools";
+import { SerpAPI } from "langchain/tools";
+import { Calculator } from "langchain/tools/calculator";
 
 const model = new OpenAI({ temperature: 0 });
 const tools = [new SerpAPI(), new Calculator()];
@@ -203,7 +204,7 @@ LangChain provides several specially created chains just for this purpose. This
 By default, the `ConversationChain` has a simple type of memory that remembers all previous inputs/outputs and adds them to the context that is passed. Let's take a look at using this chain.
 
 ```typescript
-import { OpenAI } from "langchain/llms";
+import { OpenAI } from "langchain/llms/openai";
 import { BufferMemory } from "langchain/memory";
 import { ConversationChain } from "langchain/chains";
 

docs/docs/getting-started/install.md

@@ -4,13 +4,15 @@ sidebar_position: 1
 
 # Setup and Installation
 
-## Quickstart
+:::info
+Updating from <0.0.52? See [this section](#updating-from-0052) for instructions.
+:::
 
-To get started with Langchain, you'll need to initialize a new Node.js project and configure some scripts to build, format, and compile your code.
+## Quickstart
 
-If you just want to get started quickly, [clone this repository](https://github.com/domeccleston/langchain-ts-starter) and follow the README instructions for a boilerplate project with those dependencies set up.
+If you want to get started quickly on using LangChain in Node.js, [clone this repository](https://github.com/domeccleston/langchain-ts-starter) and follow the README instructions for a boilerplate project with those dependencies set up.
 
-If you'd prefer to set things up yourself, read on for instructions.
+If you prefer to set things up yourself, or you want to run LangChain in other environments, read on for instructions.
 
 ## Installation
 
@@ -20,20 +22,18 @@ To get started, install LangChain with the following command:
 npm install -S langchain
 ```
 
-We currently support LangChain on Node.js 18 and 19. Go [here](https://github.com/hwchase17/langchainjs/discussions/152) to vote on the next environment we should support.
-
 ### TypeScript
 
 LangChain is written in TypeScript and provides type definitions for all of its public APIs.
 
 ## Loading the library
 
-### ESM in Node.js
+### ESM
 
 LangChain provides an ESM build targeting Node.js environments. You can import it using the following syntax:
 
 ```typescript
-import { OpenAI } from "langchain/llms";
+import { OpenAI } from "langchain/llms/openai";
 ```
 
 If you are using TypeScript in an ESM project we suggest updating your `tsconfig.json` to include the following:
@@ -48,25 +48,59 @@ If you are using TypeScript in an ESM project we suggest updating your `tsconfig
 }
 ```
 
-### CommonJS in Node.js
+### CommonJS
 
 LangChain provides a CommonJS build targeting Node.js environments. You can import it using the following syntax:
 
 ```typescript
-const { OpenAI } = require("langchain/llms");
+const { OpenAI } = require("langchain/llms/openai");
+```
+
+### Cloudflare Workers
+
+LangChain can be used in Cloudflare Workers. You can import it using the following syntax:
+
+```typescript
+import { OpenAI } from "langchain/llms/openai";
 ```
 
-### Other environments
+### Vercel / Next.js
+
+LangChain can be used in Vercel / Next.js. We support using LangChain in frontend components, in Serverless functions and in Edge functions. You can import it using the following syntax:
+
+```typescript
+import { OpenAI } from "langchain/llms/openai";
+```
+
+If you want to use LangChain in frontend `pages`, you need to add the following to your `next.config.js` to enable support for WebAssembly modules (which is required by the tokenizer library `@dqbd/tiktoken`):
+
+```js
+const nextConfig = {
+  webpack(config) {
+    config.experiments = {
+      asyncWebAssembly: true,
+      layers: true,
+    };
+
+    return config;
+  },
+};
+```
 
-LangChain currently supports only Node.js-based environments. This includes Vercel Serverless functions (but not Edge functions), as well as other serverless environments, like AWS Lambda and Google Cloud Functions.
+## Updating from <0.0.52
 
-We currently do not support running LangChain in the browser. We are listening to the community on additional environments that we should support. Go [here](https://github.com/hwchase17/langchainjs/discussions/152) to vote and discuss the next environments we should support.
+If you are updating from a version of LangChain prior to 0.0.52, you will need to update your imports to use the new path structure. For example, if you were previously importing `OpenAI` from `langchain/llms`, you will now need to import it from `langchain/llms/openai`. This applies to all imports from
 
-Please see [Deployment](../production/deployment.md) for more information on deploying LangChain applications.
+- `langchain/llms`, see [LLMs](../modules/models/llms/integrations)
+- `langchain/chat_models`, see [Chat Models](../modules/models/chat/integrations)
+- `langchain/embeddings`, see [Embeddings](../modules/models/embeddings/integrations)
+- `langchain/vectorstores`, see [Vector Stores](../modules/indexes/vector_stores/integrations/)
+- `langchain/document_loaders`, see [Document Loaders](../modules/indexes/document_loaders/examples/)
+- `langchain/retrievers`, see [Retrievers](../modules/indexes/retrievers/)
 
 ## Unsupported: Node.js 16
 
-We do not support Node.js 16, but if you want to run LangChain on Node.js 16, you will need to follow the instructions in this section. We do not guarantee that these instructions will continue to work in the future.
+We do not support Node.js 16, but if you still want to run LangChain on Node.js 16, you will need to follow the instructions in this section. We do not guarantee that these instructions will continue to work in the future.
 
 You will have to make `fetch` available globally, either:
 

docs/docs/modules/agents/executor/getting-started.md

@@ -24,9 +24,10 @@ SERPAPI_API_KEY="..."
 Now we can get started!
 
 ```typescript
-import { OpenAI } from "langchain";
+import { OpenAI } from "langchain/llms/openai";
 import { initializeAgentExecutor } from "langchain/agents";
-import { SerpAPI, Calculator } from "langchain/tools";
+import { SerpAPI } from "langchain/tools";
+import { Calculator } from "langchain/tools/calculator";
 
 const model = new OpenAI({ temperature: 0 });
 const tools = [new SerpAPI(), new Calculator()];

docs/docs/modules/agents/toolkits/examples/json.md

@@ -3,9 +3,9 @@
 This example shows how to load and use an agent with a JSON toolkit.
 
 ```typescript
-import { OpenAI } from "langchain";
 import * as fs from "fs";
 import * as yaml from "js-yaml";
+import { OpenAI } from "langchain/llms/openai";
 import { JsonSpec, JsonObject } from "langchain/tools";
 import { JsonToolkit, createJsonAgent } from "langchain/agents";
 

docs/docs/modules/agents/toolkits/examples/openapi.md

@@ -5,9 +5,9 @@ This example shows how to load and use an agent with a OpenAPI toolkit.
 ```typescript
 import * as fs from "fs";
 import * as yaml from "js-yaml";
+import { OpenAI } from "langchain/llms/openai";
 import { JsonSpec, JsonObject } from "langchain/tools";
 import { createOpenApiAgent, OpenApiToolkit } from "langchain/agents";
-import { OpenAI } from "langchain";
 
 export const run = async () => {
   let data: JsonObject;

docs/docs/modules/agents/toolkits/examples/vectorstore.md

@@ -3,9 +3,9 @@
 This example shows how to load and use an agent with a vectorstore toolkit.
 
 ```typescript
-import { OpenAI } from "langchain";
-import { HNSWLib } from "langchain/vectorstores";
-import { OpenAIEmbeddings } from "langchain/embeddings";
+import { OpenAI } from "langchain/llms/openai";
+import { HNSWLib } from "langchain/vectorstores/hnswlib";
+import { OpenAIEmbeddings } from "langchain/embeddings/openai";
 import { RecursiveCharacterTextSplitter } from "langchain/text_splitter";
 import * as fs from "fs";
 import {

docs/docs/modules/agents/tools/agents_with_vectorstores.md

@@ -7,12 +7,12 @@ The recommended method for doing so is to create a VectorDBQAChain and then use
 First, you'll want to import the relevant modules:
 
 ```typescript
-import { OpenAI } from "langchain";
+import { OpenAI } from "langchain/llms/openai";
 import { initializeAgentExecutor } from "langchain/agents";
 import { SerpAPI, Calculator, ChainTool } from "langchain/tools";
 import { VectorDBQAChain } from "langchain/chains";
-import { HNSWLib } from "langchain/vectorstores";
-import { OpenAIEmbeddings } from "langchain/embeddings";
+import { HNSWLib } from "langchain/vectorstores/hnswlib";
+import { OpenAIEmbeddings } from "langchain/embeddings/openai";
 import { RecursiveCharacterTextSplitter } from "langchain/text_splitter";
 import * as fs from "fs";
 ```

docs/docs/modules/agents/tools/index.mdx

@@ -47,7 +47,7 @@ The `DynamicTool` class takes as input a name, a description, and a function. Im
 See below for an example of defining and using `DynamicTool`s.
 
 ```typescript
-import { OpenAI } from "langchain";
+import { OpenAI } from "langchain/llms/openai";
 import { initializeAgentExecutor } from "langchain/agents";
 import { DynamicTool } from "langchain/tools";