Docs Menu
Docs Home
/ /

Comenzar con la integración LangChain JS/TS

Nota

Este tutorial utiliza LangChain Biblioteca de JavaScriptPara ver un tutorial que utiliza la biblioteca de Python, consulte Cadena de bloques Python.

Puede integrar MongoDB Vector Search con LangChain para crear aplicaciones LLM e implementar la generación aumentada por recuperación (RAG). Este tutorial muestra cómo empezar a usar MongoDB Vector Search con LangChain para realizar búsquedas semánticas en sus datos y crear una Implementación deRAG. En concreto, se realizan las siguientes acciones:

  1. Configura el entorno.

  2. Almacenar datos personalizados en MongoDB.

  3. Cree un índice de búsqueda vectorial MongoDB en sus datos.

  4. Ejecuta las siguientes consultas de búsqueda vectorial:

    • Búsqueda semántica.

    • Búsqueda semántica con prefiltrado de metadatos.

    • Búsqueda de relevancia marginal máxima (MMR).

  5. Implementa RAG usando la búsqueda vectorial de MongoDB para responder preguntas sobre tus datos.

LangChain es un framework de código abierto que simplifica la creación de aplicaciones LLM mediante el uso de cadenas. Estas cadenas son componentes específicos de LangChain que pueden combinarse para diversos casos de uso de IA, incluyendo RAG.

Al integrar MongoDB Vector Search con LangChain, puede usar MongoDB como base de datos vectorial y usar MongoDB Vector Search para implementar RAG recuperando documentos semánticamente similares de sus datos. Para obtener más información sobre RAG, consulte Generación Aumentada por Recuperación (RAG) con MongoDB.

Para completar este tutorial, debes tener lo siguiente:

  • Uno de los siguientes tipos de clúster de MongoDB:

  • Una clave API de Voyage AI. Para crear una clave API, consulta Claves API de modelos.

  • Una llave de API de OpenAI. Debes tener una cuenta de OpenAI con créditos disponibles para las solicitudes de API. Para obtener más información sobre cómo registrar una cuenta de OpenAI, consulta el sitio web de la API de OpenAI.

  • Una terminal y editor de código para ejecutar el proyecto de Node.js.

  • npm y Node.js instalados.

Configura el entorno para este tutorial. Para configurarlo, sigue estos pasos.

1

Ejecute los siguientes comandos en su terminal para crear un nuevo directorio llamado langchain-mongodb e inicializa tu proyecto:

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

Ejecuta el siguiente comando:

npm install langchain @langchain/community @langchain/mongodb @langchain/openai @langchain/textsplitters pdf-parse fs
3

El proyecto se debe configurar para usar módulos ES agregando "type": "module" al archivo package.json y luego guardándolo.

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

En tu proyecto, crea un archivo llamado get-started.js y copia y pega el siguiente código en él. Agregarás código a este archivo a lo largo del tutorial.

Este initial code snippet importa los paquetes necesarios para este tutorial, define variables de entorno y establece una conexión con tu MongoDB clúster.

import { formatDocumentsAsString } from "langchain/util/document";
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);
5

Para finalizar la configuración del entorno, reemplace los <api-key> <connection-string> valores de marcador de posición y en get-started.js con su clave de API de Voyage AI, su clave de API de OpenAI y la cadena de conexión SRVde su clúster de MongoDB, respectivamente. Su cadena de conexión debe tener el siguiente formato:

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

En esta sección, defines una función asíncrona para cargar datos personalizados en MongoDB e instanciar tu clúster de MongoDB como una base de datos vectorial, que también se llama almacén vectorial. Agrega el siguiente código a tu archivo get-started.js.

Nota

Para este tutorial, utilizará un documento PDF de acceso público titulado "Mejores prácticas de MongoDB Atlas" como fuente de datos para su almacén de vectores. Este documento describe diversas recomendaciones y conceptos clave para administrar sus implementaciones de MongoDB.

Este código realiza las siguientes acciones:

  • Configura su colección MongoDB especificando los siguientes parámetros:

    • langchain_db.test como la colección MongoDB para almacenar los documentos.

    • vector_index como el índice a utilizar para consultar el almacén de vectores.

    • text como el nombre del campo que contiene el contenido de texto sin formato.

    • embedding como el nombre del campo que contiene las incrustaciones vectoriales.

  • Prepara tus datos personalizados de la siguiente manera:

    • Recupera datos sin procesar de la URL especificada y los guarda como PDF.

    • Utiliza un divisor de texto para dividir los datos en documentos más pequeños.

    • Especifica los parámetros del fragmento, que determinan la cantidad de caracteres en cada documento y la cantidad de caracteres que deben superponerse entre dos documentos consecutivos.

  • Crea un almacén vectorial a partir de los documentos de ejemplo mediante el método MongoDBAtlasVectorSearch.fromDocuments. Este método especifica los siguientes parámetros:

    • Los documentos de muestra para almacenar en la base de datos vectorial.

    • Modelo de incrustación de Voyage AI como modelo utilizado para convertir texto en incrustaciones vectoriales para el campo embedding.

    • Su configuración de clúster MongoDB.

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({ model: "voyage-3-large" });
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);

Guarde el archivo y luego ejecute el siguiente comando para cargar sus datos en MongoDB.

node get-started.js

Tip

Después de get-started.js ejecutar, si está usando Atlas, puede verificar sus incrustaciones vectoriales navegando al espacio de nombres en langchain_db.test la interfaz de usuario de Atlas.

Para habilitar consultas de búsqueda de vectores en su tienda de vectores, cree un índice de búsqueda de vectores de MongoDB en la colección langchain_db.test.

Agregue el siguiente código a la función asíncrona definida en su get-started.js archivo. Este código crea un índice del tipo vectorSearch que indexa los siguientes campos:

  • embedding campo como tipo de vector. El embedding campo contiene las incrustaciones creadas con el voyage-3-large modelo de incrustación de Voyage AI. La definición del índice especifica las 1024 dimensiones del vector y mide la similitud cosine mediante.

  • loc.pageNumber campo como el tipo filtro para prefiltrar datos por el número de página en el PDF.

Este código también utiliza una función de espera para garantizar que su índice de búsqueda se haya sincronizado con sus datos antes de su uso.

1// Ensure index does not already exist, then create your MongoDB Vector Search index
2const indexes = await collection.listSearchIndexes("vector_index").toArray();
3if(indexes.length === 0){
4
5 // Define your MongoDB Vector Search Index
6 const index = {
7 name: "vector_index",
8 type: "vectorSearch",
9 definition: {
10 "fields": [
11 {
12 "type": "vector",
13 "numDimensions": 1024,
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 index to build and become queryable
30 console.log("Waiting for initial sync...");
31 await new Promise(resolve => setTimeout(() => {
32 resolve();
33 }, 10000));
34}

Guarde el archivo y luego ejecute el siguiente comando para crear su índice de búsqueda vectorial MongoDB.

node get-started.js

Esta sección muestra varias consultas que puede ejecutar en sus datos vectorizados. Ahora que ha creado el índice, agregue el siguiente código a su función asíncrona para ejecutar consultas de búsqueda vectorial en sus datos.

Nota

Si obtiene resultados inexactos al consultar sus datos, es posible que su índice esté tardando más de lo esperado en sincronizarse. Aumente el número en la función setTimeout para que la sincronización inicial tenga más tiempo.

1

El siguiente código utiliza el método similaritySearch para realizar una búsqueda semántica básica de la cadena MongoDB Atlas security. Devuelve una lista de documentos ordenados por relevancia, con solo los campos pageContent y pageNumber.

// 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)
2
node get-started.js
Semantic Search Results:
[
{
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: '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: '• 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: 'are updated, associated indexes must be maintained, incurring additional CPU and disk I/O overhead. \n' +
'If you\'re running fully managed databases on MongoDB Atlas, the built-in Performance Advisor',
pageNumber: 20
}
]

Puedes prefiltrar tus datos utilizando una expresión de coincidencia MQL que compare el campo indexado con otro valor de tu colección. Debes indexar cualquier campo de metadatos que desees filtrar como tipo filter. Para obtener más información, consulta Cómo indexar campos para la búsqueda vectorial.

Nota

Usted especificó el loc.pageNumber campo como filtro cuando creó el índice para este tutorial.

1

El siguiente código utiliza el método similaritySearch para realizar una búsqueda semántica de la cadena MongoDB Atlas security. Especifica los siguientes parámetros:

  • El número de documentos a devolver es 3.

  • Un prefiltro en el loc.pageNumber campo que utiliza el $eq operador para hacer coincidir los documentos que aparecen 17 solo en la página.

Retorna una lista de documentos clasificados por relevancia con sólo los campos pageContent y pageNumber.

// 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)
2
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
}
]

También puede realizar una búsqueda semántica basada en la relevancia marginal máxima (MMR), una medida de relevancia semántica optimizada para la diversidad.

1

El siguiente código utiliza el método maxMarginalRelevanceSearch para buscar la cadena MongoDB Atlas security. También especifica un objeto que define los siguientes parámetros opcionales:

  • k para limitar el número de documentos devueltos a 3.

  • fetchK para obtener solo 10 documentos antes de pasarlos al algoritmo MMR.

Retorna una lista de documentos clasificados por relevancia con sólo los campos pageContent y pageNumber.

// 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)
2
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
}
]

Tip

Para obtener más información, consulte la referencia de API.

Esta sección muestra dos implementaciones diferentes de RAG con MongoDB Vector Search y LangChain. Ahora que ha utilizado MongoDB Vector Search para recuperar documentos semánticamente similares, utilice los siguientes ejemplos de código para solicitar al LLM que responda preguntas sobre los documentos devueltos por MongoDB Vector Search.

1

Este código realiza lo siguiente:

  • Crea una instancia de MongoDB Vector Search como un recuperador para consultar documentos semánticamente similares.

  • Define una plantilla de solicitud de LangChain para indicar al LLM que utilice estos documentos como contexto para su consulta. LangChain pasa estos documentos a la {context} variable de entrada y su consulta a la {question} variable.

  • Construye una cadena que utiliza el modelo de chat de OpenAI para generar respuestas sensibles al contexto basadas en su mensaje.

  • Solicita a la cadena una consulta de muestra sobre las recomendaciones de seguridad de Atlas.

  • Devuelve la respuesta del LLM y los documentos utilizados como contexto.

// 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))
2

Después de guardar el archivo, ejecute el siguiente comando. La respuesta generada puede variar.

node get-started.js
Question: How can I secure my MongoDB Atlas cluster?
Answer: The given context does not explicitly provide detailed steps to secure a MongoDB Atlas cluster. However, based on general best practices, here are some common steps to secure your MongoDB Atlas cluster:
1. **Enable Network Access Controls**: Configure IP whitelists to only allow connections from trusted IP addresses.
2. **Use Strong Authentication and Authorization**: Enable SCRAM (Salted Challenge Response Authentication Mechanism) for authenticating users and define roles with specific permissions.
3. **Encrypt Data**: Ensure data is encrypted both at rest and in transit by default in MongoDB Atlas.
4. **Enable VPC Peering (if applicable)**: Use Virtual Private Cloud (VPC) peering for secure and private connections.
5. **Monitor Activity**: Use MongoDB Atlas's built-in monitoring to track cluster activity and detect unauthorized attempts or anomalies.
6. **Implement Automated Backups**: Secure backups and ensure they are protected from unauthorized access.
7. **Educate Yourself**: Continuously refer to the MongoDB documentation and follow security best practices.
It is recommended to visit the MongoDB documentation and security guides for the most accurate and detailed steps tailored to your specific use case.
Source documents:
[
{
"pageContent": "Atlas free tier, or download MongoDB for local \ndevelopment.\nReview the MongoDB manuals and tutorials in our \ndocumentation. \nMore Resources\nFor more on getting started in MongoDB:",
"pageNumber": 30
},
{
"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": "• Zoned Sharding — You can define specific rules governing data placement in a sharded cluster.\nGlobal Clusters in MongoDB Atlas allows you to quickly implement zoned sharding using a visual UI or",
"pageNumber": 27
},
{
"pageContent": "22\nWorkload Type: Search\nIf your application requires rich full-text search functionality and you are running MongoDB on Atlas,",
"pageNumber": 22
}
]
1

Este código realiza lo siguiente:

  • Crea una instancia de MongoDB Vector Search como recuperador para consultar documentos semánticamente similares. También especifica los siguientes parámetros opcionales:

    • searchType como mmr, lo que especifica que MongoDB búsqueda vectorial recupera documentos en función de la Relevancia Marginal Máxima (MMR).

    • filter para agregar un prefiltro en el campo log.pageNumbers para incluir documentos que aparecen solo en la página 17.

    • Los siguientes parámetros específicos de MMR:

      • fetchK para obtener solo 20 documentos antes de pasarlos al algoritmo MMR.

      • lambda, un valor entre 0 y 1 para determinar el grado de diversidad entre los resultados, donde 0 representa la máxima diversidad y 1 la mínima diversidad.

  • Define una plantilla de solicitud de LangChain para indicar al LLM que utilice estos documentos como contexto para su consulta. LangChain pasa estos documentos a la {context} variable de entrada y su consulta a la {question} variable.

  • Construye una cadena que utiliza el modelo de chat de OpenAI para generar respuestas sensibles al contexto basadas en su mensaje.

  • Solicita a la cadena una consulta de muestra sobre las recomendaciones de seguridad de Atlas.

  • Devuelve la respuesta del LLM y los documentos utilizados como contexto.

// 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))
2

Después de guardar el archivo, ejecute el siguiente comando. La respuesta generada puede variar.

node get-started.js
Question: How can I secure my MongoDB Atlas cluster?
Answer: To secure your MongoDB Atlas cluster, you can implement the following best practices:
1. **Enable Authentication and Authorization**
Ensure that authentication is enabled, which is the default for MongoDB Atlas. Use role-based access control (RBAC) to grant users only the permissions they need.
2. **Use Strong Passwords or Authentication Mechanisms**
Avoid simple passwords. Use strong, complex passwords for all database users. Alternatively, use certificate-based authentication or federated authentication with your identity provider.
3. **Whitelist IP Addresses**
Configure your Access List (IP Whitelist) to restrict access to trusted IP addresses. This ensures that only specified IP addresses can connect to your cluster.
4. **Enable Network Encryption (TLS/SSL)**
MongoDB Atlas supports TLS/SSL by default for securing data in transit. Ensure applications are configured to connect with SSL/TLS-enabled settings.
5. **Use End-to-End Encryption (Client-Side Field-Level Encryption)**
Implement client-side field-level encryption to ensure sensitive fields are encrypted end-to-end.
6. **Regularly Rotate Authentication Credentials**
Periodically rotate users' passwords or access keys to mitigate the risks of credential exposure.
7. **Use Private Networking**
If supported, use Virtual Private Cloud (VPC) peering or private endpoints, such as AWS PrivateLink, to connect securely to your MongoDB Atlas cluster without using the public internet.
8. **Enable Database Auditing**
Enable auditing to track database activity and detect potential anomalies or unauthorized access.
9. **Enable Backup and Data Recovery**
Regularly back up your data using MongoDB Atlas' automated backup systems to ensure business continuity in case of accidental deletions or data loss.
10. **Keep the MongoDB Drivers Updated**
Use the latest version of MongoDB drivers in your application to benefit from security updates and enhancements.
11. **Monitor and Set Alerts**
Use MongoDB Atlas' monitoring tools to track metrics and set up alerts for suspicious activities or unusual resource consumption.
12. **Implement Application-Level Security**
Ensure your application properly handles user authentication, session management, and input sanitization to prevent unauthorized access or injection attacks.
13. **Watch for Security Best Practices Updates**
Regularly review MongoDB Atlas documentation and security advisories to stay aware of new features and recommendations.
By following these practices, you can greatly enhance the security posture of your MongoDB Atlas cluster.
Source documents:
[
{
"pageContent": "Optimizing Data \nAccess Patterns\nNative tools in MongoDB for improving query \nperformance and reducing overhead.",
"pageNumber": 17
}
]

Para aprender cómo integrar MongoDB Vector Search con LangGraph, consulte Integrar MongoDB con LangGraph.js.

MongoDB también proporciona los siguientes recursos para desarrolladores:

Volver

Queries en lenguaje natural

En esta página