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 Retrieval-Augmented Generation (RAG) with Atlas Vector Search.

Prerequisites

To complete this tutorial, you must have the following:

• An Atlas account with a cluster running MongoDB version 6.0.11, 7.0.2, or later (including RCs). Ensure that your IP address is included in your Atlas project's access list. To learn more, see Create a Cluster.

• An OpenAI API Key. You must have an OpenAI account with credits available for API requests. To learn more about registering an OpenAI account, see the OpenAI API website.

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

• npm and Node.js installed.

Set Up the Environment

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/community @langchain/mongodb @langchain/openai pdf-parse fs

{
  "type": "module",
  // other fields...
}

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/community/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://<db_username>:<db_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
    const count = await collection.countDocuments();
    if (count > 0) {
      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.

Add the following code to the asynchronous function that you defined in your get-started.js file. This code creates an index of the vectorSearch type that indexes the following fields:

• embedding field as the vector type. The embedding field contains the embeddings created using OpenAI's text-embedding-ada-002 embedding model. The index definition specifies 1536 vector dimensions and measures similarity using cosine.

• loc.pageNumber field as the filter type for pre-filtering data by the page number in the PDF.

This code also uses an await function to ensure that your search index has synced to your data before it's used.

1
// Ensure index does not already exist, then create your Atlas Vector Search index
2
const indexes = await collection.listSearchIndexes("vector_index").toArray();
3
if(indexes.length === 0){
4
5
   // Define your Atlas Vector Search Index
6
   const index = {
7
      name: "vector_index",
8
      type: "vectorSearch",
9
      definition: {
10
         "fields": [
11
            {
12
               "type": "vector",
13
               "numDimensions": 1536,
14
               "path": "embedding",
15
               "similarity": "cosine"
16
            },
17
            {
18
               "type": "filter",
19
               "path": "loc.pageNumber"
20
            }
21
         ]
22
      }
23
   }
24
25
   // Run the helper method
26
   const result = await collection.createSearchIndex(index);
27
   console.log(result);
28
29
   // Wait for Atlas to sync index
30
   console.log("Waiting for initial sync...");
31
   await new Promise(resolve => setTimeout(() => {
32
      resolve();
33
   }, 10000));
34
}

Save the file, then run the following command to create you Atlas Vector Search index.

node get-started.js

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.

// Basic semantic search
const basicOutput = await vectorStore.similaritySearch("MongoDB Atlas security");
const basicResults = basicOutput.map((results => ({
pageContent: results.pageContent,
pageNumber: results.metadata.loc.pageNumber,
})))
console.log("Semantic Search Results:")
console.log(basicResults)

node get-started.js

...
Semantic Search Results:
[
   {
      pageContent: 'MongoDB Atlas features extensive capabilities to defend,\n' +
         'detect, and control access to MongoDB, offering among\n' +
         'the most complete security controls of any modern\n' +
         'database:',
      pageNumber: 18
   },
   {
      pageContent: 'Atlas provides encryption of data at rest with encrypted\n' +
         'storage volumes.\n' +
         'Optionally, Atlas users can configure an additional layer of\n' +
         'encryption on their data at rest using the MongoDB',
      pageNumber: 19
   },
   {
      pageContent: 'automatically enabled.\n' +
         'Review thesecurity section of the MongoDB Atlas\n' +
         'documentationto learn more about each of the security\n' +
         'features discussed below.\n' +
         'IP Whitelisting',
      pageNumber: 18
   },
   {
      pageContent: '16Security\n' +
         '17Business Intelligence with MongoDB Atlas\n' +
         '18Considerations for Proofs of Concept\n' +
         '18MongoDB Stitch: Serverless Platform from MongoDB\n' +
         '19We Can Help\n' +
         '19Resources',
      pageNumber: 2
   }
]

// Semantic search with metadata filter
const filteredOutput = await vectorStore.similaritySearch("MongoDB Atlas security", 3, {
preFilter: {
   "loc.pageNumber": {"$eq": 17 },
}
});
const filteredResults = filteredOutput.map((results => ({
pageContent: results.pageContent,
pageNumber: results.metadata.loc.pageNumber,
})))
console.log("Semantic Search with Filtering Results:")
console.log(filteredResults)

node get-started.js

...
Semantic Search with Filter Results:
[
   {
      pageContent: 'BSON database dumps produced bymongodump.\n' +
         'In the vast majority of cases, MongoDB Atlas backups\n' +
         'delivers the simplest, safest, and most efficient backup',
      pageNumber: 17
   },
   {
      pageContent: 'Monitoring Solutions\n' +
         'The MongoDB Atlas API provides integration with external\n' +
         'management frameworks through programmatic access to\n' +
         'automation features and alerts.\n' +
         'APM Integration',
      pageNumber: 17
   },
   {
      pageContent: 'MongoDB Atlas backups are maintained continuously, just\n' +
         'a few seconds behind the operational system. If the\n' +
         'MongoDB cluster experiences a failure, the most recent',
      pageNumber: 17
   }
]

// Max Marginal Relevance search
const mmrOutput = await vectorStore.maxMarginalRelevanceSearch("MongoDB Atlas security", {
k: 3,
fetchK: 10,
});
const mmrResults = mmrOutput.map((results => ({
pageContent: results.pageContent,
pageNumber: results.metadata.loc.pageNumber,
})))
console.log("Max Marginal Relevance Search Results:")
console.log(mmrResults)

node get-started.js

...
Max Marginal Relevance Search Results:
[
   {
      pageContent: 'MongoDB Atlas features extensive capabilities to defend,\n' +
         'detect, and control access to MongoDB, offering among\n' +
         'the most complete security controls of any modern\n' +
         'database:',
      pageNumber: 18
   },
   {
      pageContent: 'automatically enabled.\n' +
         'Review thesecurity section of the MongoDB Atlas\n' +
         'documentationto learn more about each of the security\n' +
         'features discussed below.\n' +
         'IP Whitelisting',
      pageNumber: 18
   },
   {
      pageContent: '16Security\n' +
         '17Business Intelligence with MongoDB Atlas\n' +
         '18Considerations for Proofs of Concept\n' +
         '18MongoDB Stitch: Serverless Platform from MongoDB\n' +
         '19We Can Help\n' +
         '19Resources',
      pageNumber: 2
   }
]

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.

// Implement RAG to answer questions on your data 
const retriever = vectorStore.asRetriever();
const prompt =
  PromptTemplate.fromTemplate(`Answer the question based on the following context:
  {context}
  Question: {question}`);
const model = new ChatOpenAI({});
const chain = RunnableSequence.from([
  {
    context: retriever.pipe(formatDocumentsAsString),
    question: new RunnablePassthrough(),
  },
  prompt,
  model,
  new StringOutputParser(),
]);
// Prompt the LLM
const question = "How can I secure my MongoDB Atlas cluster?";  
const answer = await chain.invoke(question);
console.log("Question: " + question);
console.log("Answer: " + answer);
// Return source documents
const retrievedResults = await retriever.getRelevantDocuments(question)
const documents = retrievedResults.map((documents => ({
  pageContent: documents.pageContent,
  pageNumber: documents.metadata.loc.pageNumber,
})))
console.log("\nSource documents:\n" + JSON.stringify(documents, 1, 2))

node get-started.js

...
Question: How can I secure my MongoDB Atlas cluster?
Answer: You can secure your MongoDB Atlas cluster by taking
advantage of extensive capabilities to defend, detect, and control
access to MongoDB. You can also enable encryption of data at rest
with encrypted storage volumes and configure an additional layer of
encryption on your data. Additionally, you can set up global clusters
on Amazon Web Services, Microsoft Azure, and Google Cloud Platform
with just a few clicks in the MongoDB Atlas UI.
Source documents:
[
  {
    "pageContent": "MongoDB Atlas features extensive capabilities to defend,\ndetect, and control access to MongoDB, offering among\nthe most complete security controls of any modern\ndatabase:",
    "pageNumber": 18
  },
  {
    "pageContent": "throughput is required, it is recommended to either\nupgrade the Atlas cluster or take advantage of MongoDB's\nauto-shardingto distribute read operations across multiple\nprimary members.",
    "pageNumber": 14
  },
  {
    "pageContent": "Atlas provides encryption of data at rest with encrypted\nstorage volumes.\nOptionally, Atlas users can configure an additional layer of\nencryption on their data at rest using the MongoDB",
    "pageNumber": 19
  },
  {
    "pageContent": "You can set up global clusters — available on Amazon Web\nServices, Microsoft Azure, and Google Cloud Platform —\nwith just a few clicks in the MongoDB Atlas UI. MongoDB",
    "pageNumber": 13
  }
]

// Implement RAG to answer questions on your data 
const retriever = await vectorStore.asRetriever({
    searchType: "mmr", // Defaults to "similarity
    filter: { preFilter: { "loc.pageNumber": { "$eq": 17 } } },
    searchKwargs: {
      fetchK: 20,
      lambda: 0.1,
    },
  });
const prompt =
  PromptTemplate.fromTemplate(`Answer the question based on the following context:
  {context}
  Question: {question}`);
const model = new ChatOpenAI({});
const chain = RunnableSequence.from([
  {
    context: retriever.pipe(formatDocumentsAsString),
    question: new RunnablePassthrough(),
  },
  prompt,
  model,
  new StringOutputParser(),
]);
// Prompt the LLM
const question = "How can I secure my MongoDB Atlas cluster?";  
const answer = await chain.invoke(question);
console.log("Question: " + question);
console.log("Answer: " + answer);
// Return source documents
const retrievedResults = await retriever.getRelevantDocuments(question)
const documents = retrievedResults.map((documents => ({
  pageContent: documents.pageContent,
  pageNumber: documents.metadata.loc.pageNumber,
})))
console.log("\nSource documents:\n" + JSON.stringify(documents, 1, 2))

node get-started.js

...
Question: How can I secure my MongoDB Atlas cluster?
Answer: To secure your MongoDB Atlas cluster, you can take the following measures:
1. Enable authentication and use strong, unique passwords for all users.
2. Utilize encryption in transit and at rest to protect data both while in motion and at rest.
3. Configure network security by whitelisting IP addresses that can access your cluster.
4. Enable role-based access control to limit what actions users can perform within the cluster.
5. Monitor and audit your cluster for suspicious activity using logging and alerting features.
6. Keep your cluster up to date with the latest patches and updates to prevent vulnerabilities.
7. Implement backups and disaster recovery plans to ensure you can recover your data in case of data loss.
Source documents:
[
  {
    "pageContent": "BSON database dumps produced bymongodump.\nIn the vast majority of cases, MongoDB Atlas backups\ndelivers the simplest, safest, and most efficient backup",
    "pageNumber": 17
  },
  {
    "pageContent": "APM Integration\nMany operations teams use Application Performance\nMonitoring (APM) platforms to gain global oversight of\n15",
    "pageNumber": 17
  },
  {
    "pageContent": "performance SLA.\nIf in the course of a deployment it is determined that a new\nshard key should be used, it will be necessary to reload the\ndata with a new shard key because designation and values",
    "pageNumber": 17
  },
  {
    "pageContent": "to the database.\nReplication Lag\nReplication lag is the amount of time it takes a write\noperation on the primary replica set member to replicate to",
    "pageNumber": 17
  }
]

Next Steps

To learn how to integrate Atlas Vector Search with LangGraph, see Integrate MongoDB with LangGraph.js.

MongoDB also provides the following developer resources:

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

• MongoDB Developer GitHub Repository