Get Started with the LangChain JS/TS Integration

Background

LangChain is an open-source framework that simplifies the creation of LLM applications through the use of "chains." Chains are LangChain-specific components that can be combined for a variety of AI use cases, including RAG.

By integrating Atlas Vector Search with LangChain, you can use Atlas as a vector database and use Atlas Vector Search to implement RAG by retrieving semantically similar documents from your data. To learn more about RAG, see Key Concepts.

Prerequisites

To complete this tutorial, you must have the following:

• An Atlas cluster running MongoDB version 6.0.11, 7.0.2, or later (including RCs).

• An OpenAI API Key. You must have a paid OpenAI account with credits available for API requests.

• A terminal and code editor to run your Node.js project.

• npm and Node.js installed.

Set Up the Environment

You must first set up the environment for this tutorial. To set up your environment, complete the following steps.

mkdir langchain-mongodb
cd langchain-mongodb
npm init -y

npm install langchain @langchain/mongodb @langchain/openai pdf-parse fs

{
   "name": "langchain-mongodb",
   "type": "module",
   ...

import { formatDocumentsAsString } from "langchain/util/document";
import { MongoClient } from "mongodb";
import { MongoDBAtlasVectorSearch } from "@langchain/mongodb";
import { OpenAIEmbeddings, ChatOpenAI } from "@langchain/openai";
import { PDFLoader } from "langchain/document_loaders/fs/pdf";
import { PromptTemplate } from "@langchain/core/prompts";
import { RecursiveCharacterTextSplitter } from "langchain/text_splitter";
import { RunnableSequence, RunnablePassthrough } from "@langchain/core/runnables";
import { StringOutputParser } from "@langchain/core/output_parsers";
import * as fs from 'fs';
process.env.OPENAI_API_KEY = "<api-key>";
process.env.ATLAS_CONNECTION_STRING = "<connection-string>";
const client = new MongoClient(process.env.ATLAS_CONNECTION_STRING);

mongodb+srv://<username>:<password>@<clusterName>.<hostname>.mongodb.net

Use Atlas as a Vector Store

In this section, you define an asynchronous function to load custom data into Atlas and instantiate Atlas as a vector database, also called a vector store. Add the following code into your get-started.js file.

This code performs the following actions:

• Configures your Atlas collection by specifying the following parameters:

  • langchain_db.test as the Atlas collection to store the documents.

  • vector_index as the index to use for querying the vector store.

  • text as the name of the field containing the raw text content.

  • embedding as the name of the field containing the vector embeddings.

• Prepares your custom data by doing the following:

  • Retrieves raw data from the specified URL and saves it as PDF.

  • Uses a text splitter to split the data into smaller documents.

  • Specifies chunk parameters, which determines the number of characters in each document and the number of characters that should overlap between two consecutive documents.

• Creates a vector store from the sample documents by calling the MongoDBAtlasVectorSearch.fromDocuments method. This method specifies the following parameters:

  • The sample documents to store in the vector database.

  • OpenAI's embedding model as the model used to convert text into vector embeddings for the embedding field.

  • Your Atlas configuration.

async function run() {
  try {
    // Configure your Atlas collection
    const database = client.db("langchain_db");
    const collection = database.collection("test");
    const dbConfig = {  
      collection: collection,
      indexName: "vector_index", // The name of the Atlas search index to use.
      textKey: "text", // Field name for the raw text content. Defaults to "text".
      embeddingKey: "embedding", // Field name for the vector embeddings. Defaults to "embedding".
    };
    
    // Ensure that the collection is empty
    await collection.deleteMany({});
    // Save online PDF as a file
    const rawData = await fetch("https://query.prod.cms.rt.microsoft.com/cms/api/am/binary/RE4HkJP");
    const pdfBuffer = await rawData.arrayBuffer();
    const pdfData = Buffer.from(pdfBuffer);
    fs.writeFileSync("atlas_best_practices.pdf", pdfData);
    // Load and split the sample data
    const loader = new PDFLoader(`atlas_best_practices.pdf`);
    const data = await loader.load();
    const textSplitter = new RecursiveCharacterTextSplitter({
      chunkSize: 200,
      chunkOverlap: 20,
    });
    const docs = await textSplitter.splitDocuments(data);
    // Instantiate Atlas as a vector store
    const vectorStore = await MongoDBAtlasVectorSearch.fromDocuments(docs, new OpenAIEmbeddings(), dbConfig);
  } finally {
    // Ensure that the client will close when you finish/error
    await client.close();
  }
}
run().catch(console.dir);

Save the file, then run the following command to load your data into Atlas.

node get-started.js

Create the Atlas Vector Search Index

To enable vector search queries on your vector store, create an Atlas Vector Search index on the langchain_db.test collection.

// Wait for Atlas to sync index
console.log("Waiting for initial sync...");
await new Promise(resolve => setTimeout(() => {
  resolve();
}, 10000));

Run Vector Search Queries

This section demonstrates various queries that you can run on your vectorized data. Now that you've created the index, add the following code to your asynchronous function to run vector search queries against your data.

Answer Questions on Your Data

This section demonstrates two different RAG implementations using Atlas Vector Search and LangChain. Now that you've used Atlas Vector Search to retrieve semantically similar documents, use the following code examples to prompt the LLM to answer questions against the documents returned by Atlas Vector Search.

Next Steps

MongoDB also provides the following developer resources:

• AI Shop: The Power of LangChain, OpenAI, and MongoDB Atlas Working Together

• MongoDB Developer GitHub Repository