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 MongoDB Vector Search with LangChain, you can use MongoDB as a vector database and use MongoDB Vector Search to implement RAG by retrieving semantically similar documents from your data. To learn more about RAG, see Retrieval-Augmented Generation (RAG) with MongoDB.

Prerequisites

To complete this tutorial, you must have the following:

• One of the following MongoDB cluster types:

  • An Atlas cluster running MongoDB version 6.0.11, 7.0.2, or later. Ensure that your IP address is included in your Atlas project's access list.

  • A local Atlas deployment created using the Atlas CLI. To learn more, see Create a Local Atlas Deployment.

  • A MongoDB Community or Enterprise cluster with Search and Vector Search installed.

• A Voyage AI API key. To create an API key, see Model API Keys.

  Note

  Your API requests might fail if you don't have a payment method configured on Atlas (for API key created in the Atlas UI) or Voyage AI (for API key created directly from Voyage AI).

• 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@latest @langchain/community@latest @langchain/core@latest @langchain/mongodb@latest @langchain/openai@latest @langchain/textsplitters@latest pdf-parse@1 --legacy-peer-deps

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

import { MongoClient } from "mongodb";
import { MongoDBAtlasVectorSearch } from "@langchain/mongodb";
import { ChatOpenAI } from "@langchain/openai";
import { VoyageEmbeddings } from "@langchain/community/embeddings/voyage";
import { PDFLoader } from "@langchain/community/document_loaders/fs/pdf";
import { PromptTemplate } from "@langchain/core/prompts";
import { RecursiveCharacterTextSplitter } from "@langchain/textsplitters";
import { RunnableSequence, RunnablePassthrough } from "@langchain/core/runnables";
import { StringOutputParser } from "@langchain/core/output_parsers";
import * as fs from 'fs';
process.env.VOYAGEAI_API_KEY = "<api-key>"
process.env.OPENAI_API_KEY = "<api-key>";
process.env.MONGODB_URI = "<connection-string>";
const client = new MongoClient(process.env.MONGODB_URI);
const formatDocumentsAsString = (docs) => docs.map(d => d.pageContent).join("\n\n");

mongodb+srv://<db_username>:<db_password>@<clusterName>.<hostname>.mongodb.net

Use MongoDB as a Vector Store

In this section, you define an asynchronous function to load custom data into MongoDB and instantiate your MongoDB cluster 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 MongoDB collection by specifying the following parameters:

  • langchain_db.test as the MongoDB 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.

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

  • Your MongoDB cluster configuration.

async function run() {
  try {
    // Configure your MongoDB collection
    const database = client.db("langchain_db");
    const collection = database.collection("test");
    const dbConfig = {  
      collection: collection,
      indexName: "vector_index", // The name of the MongoDB 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://webassets.mongodb.com/MongoDB_Best_Practices_Guide.pdf");
    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 MongoDB as a vector store
    const embeddingModel = new VoyageEmbeddings({ modelName: "voyage-4" });
    embeddingModel.apiUrl = 'https://ai.mongodb.com/v1/embeddings';
    const vectorStore = await MongoDBAtlasVectorSearch.fromDocuments(docs, embeddingModel, 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 MongoDB.

node get-started.js

Create the MongoDB Vector Search Index

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

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)
if (basicResults.length === 0) {
  console.log("No results found after waiting for index sync. Check Atlas Search index status and embedding configuration.");
}

node get-started.js

Semantic Search Results:
[
  {
    pageContent: 'read isolation.  \n' +
      'With MongoDB Atlas, you can achieve workload isolation with dedicated analytics nodes. Visualization \n' +
      'tools like Atlas Charts can be configured to read from analytics nodes only.',
    pageNumber: 21
  },
  {
    pageContent: 'well-tuned queries.\n' +
      'Built-in slow query profiling is also available if you’re deploying MongoDB with Atlas.',
    pageNumber: 16
  },
  {
    pageContent: 'Atlas free tier, or download MongoDB for local \n' +
      'development.\n' +
      'Review the MongoDB manuals and tutorials in our \n' +
      'documentation. \n' +
      'More Resources\n' +
      'For more on getting started in MongoDB:',
    pageNumber: 30
  },
  {
    pageContent: 'If you are running MongoDB on your own infrastructure, you can configure replica set tags to achieve \n' +
      'read isolation.',
    pageNumber: 21
  }
]

// Semantic search with metadata filter
const filteredOutput = await vectorStore.similaritySearch("MongoDB Atlas Search", 3, {
   preFilter: {
      "loc.pageNumber": {"$eq": 22 },
   }
});
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 Filtering Results:
[
  {
    pageContent: 'Atlas Search is built for the MongoDB document data model and provides higher performance and',
    pageNumber: 22
  },
  {
    pageContent: 'Figure 9: Atlas Search queries are expressed through the MongoDB Query API and backed by the leading search engine library, \n' +
      'Apache Lucene.',
    pageNumber: 22
  },
  {
    pageContent: 'consider using Atlas Search. The service is built on fully managed Apache Lucene but exposed to users \n' +
      'through the MongoDB Aggregation Framework.',
    pageNumber: 22
  }
]

// 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: 'Atlas Search is built for the MongoDB document data model and provides higher performance and',
    pageNumber: 22
  },
  {
    pageContent: '• Zoned Sharding — You can define specific rules governing data placement in a sharded cluster.\n' +
      'Global Clusters in MongoDB Atlas allows you to quickly implement zoned sharding using a visual UI or',
    pageNumber: 27
  },
  {
    pageContent: 'read isolation.  \n' +
      'With MongoDB Atlas, you can achieve workload isolation with dedicated analytics nodes. Visualization \n' +
      'tools like Atlas Charts can be configured to read from analytics nodes only.',
    pageNumber: 21
  }
]

Answer Questions on Your Data

This section demonstrates two different RAG implementations using MongoDB Vector Search and LangChain. Now that you've used MongoDB Vector Search to retrieve semantically similar documents, use the following code examples to prompt the LLM to answer questions against the documents returned by MongoDB 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({ modelName: "gpt-5-mini" }) // Pick your preferred model. Ensure to enable it in your OpenAI settings dashboard.
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.invoke(question)
const documents = retrievedResults.map((documents => ({
  pageContent: documents.pageContent,
  pageNumber: documents.metadata.loc.pageNumber,
})))
console.log("\nSource documents:\n" + JSON.stringify(documents, null, 2))

node get-started.js

Question: How can I secure my MongoDB Atlas cluster?
Answer: You can secure your MongoDB Atlas cluster by achieving workload isolation with dedicated analytics nodes, configuring visualization tools like Atlas Charts to read from analytics nodes only, and using built-in slow query profiling if deploying with Atlas. Additionally, you can distribute replica set members across multiple data centers for added security during election and failover.
Source documents:
[
  {
    "pageContent": "read isolation.  \nWith MongoDB Atlas, you can achieve workload isolation with dedicated analytics nodes. Visualization \ntools like Atlas Charts can be configured to read from analytics nodes only.",
    "pageNumber": 21
  },
  {
    "pageContent": "If you are running MongoDB on your own infrastructure, you can configure replica set tags to achieve \nread isolation.",
    "pageNumber": 21
  },
  {
    "pageContent": "well-tuned queries.\nBuilt-in slow query profiling is also available if you’re deploying MongoDB with Atlas.",
    "pageNumber": 16
  },
  {
    "pageContent": "achieved during election and failover. \nIf possible, distribute replica set members across multiple data centers. If you’re using MongoDB Atlas,",
    "pageNumber": 24
  }
]

// 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.invoke(question)
const documents = retrievedResults.map((documents => ({
  pageContent: documents.pageContent,
  pageNumber: documents.metadata.loc.pageNumber,
})))
console.log("\nSource documents:\n" + JSON.stringify(documents, null, 2))

node get-started.js

Question: How can I secure my MongoDB Atlas cluster?
Answer: One way to secure your MongoDB Atlas cluster is by implementing proper access controls and ensuring that only authorized users have access to your data. You can also enable encryption at rest and in transit, use network security features such as VPC peering, and regularly update and patch your MongoDB database to protect against security vulnerabilities. Additionally, implementing auditing and monitoring tools can help you detect and respond to any security incidents in a timely manner.
Source documents:
[
  {
    "pageContent": "Optimizing Data  \nAccess Patterns\nNative tools in MongoDB for improving query \nperformance and reducing overhead.",
    "pageNumber": 17
  }
]

Next Steps

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

MongoDB also provides the following developer resources:

• MongoDB Developer GitHub Repository