Introdução à integração do LangChain JS/TS

Plano de fundo

LangChain é uma estrutura de código aberto que simplifica a criação de aplicativos LLM por meio do uso de "cadeias". As cadeias são componentes específicos do LangChain que podem ser combinados para uma variedade de casos de uso de IA, incluindo RAG.

Ao integrar o MongoDB Vector Search com o LangChain, você pode usar o MongoDB como um banco de dados vetorial e usar o MongoDB Vector Search para implementar RAG, recuperando documentos semanticamente semelhantes de seus dados. Para saber mais sobre RAG, consulte Geração Aumentada de Recuperação (RAG) com MongoDB.

Pré-requisitos

Para concluir este tutorial, você deve ter o seguinte:

• Um dos seguintes tipos de cluster MongoDB :

  • Um cluster do Atlas executando a versão 6.0.11 do MongoDB, 7.0.2, ou posterior. Certifique-se de que seu endereço IP esteja incluído na lista de acesso do seu projeto Atlas.

  • Um sistema local do Atlas criado utilizando o Atlas CLI. Para saber mais, consulte Criar uma implantação de Atlas local.

  • Um cluster MongoDB Community ou Enterprise com Search e Vector Search instalados.

• Uma chave de API do Voyage AI. Para criar uma chave de API, consulte Chaves de API do modelo.

  Observação

  Suas solicitações de API podem falhar se você não tiver um método de pagamento configurado no Atlas (para chave de API criada na interface do usuário do Atlas ) ou Voyage AI (para chave de API criada diretamente da Voyage AI).

• Uma chave de API da OpenAI. Você deve ter uma conta da OpenAI com créditos disponíveis para solicitações de API. Para aprender mais sobre como registrar uma conta OpenAI, consulte o website de API OpenAI.

• Um editor de terminal e código para executar seu projeto Node.js.

• npm e Node.js instalados.

Configurar o ambiente

Configure o ambiente para este tutorial. Para configurar seu ambiente, conclua as etapas a seguir.

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 o MongoDB como um armazenamento de vetores

Nesta seção, você define uma função assíncrona para carregar dados personalizados no MongoDB e instanciar seu cluster MongoDB como um banco de dados vetorial, também chamado de armazenamento vetorial. Adicione o seguinte código ao seu arquivo get-started.js.

Este código executa as seguintes ações:

• Configura sua collection MongoDB especificando os seguintes parâmetros:

  • langchain_db.test como a coleção MongoDB para armazenar os documentos.

  • vector_index como o índice a ser usado para consultar o armazenamento de vetores.

  • text como o nome do campo que contém o conteúdo de texto bruto.

  • embedding como o nome do campo que contém as incorporações do vetor.

• Prepara seus dados personalizados fazendo o seguinte:

  • Recupera dados brutos da URL especificada e os salva como PDF.

  • Usa um divisor de texto para divisão os dados em documentos menores.

  • Especifica os parâmetros de parte, que determinam o número de caracteres em cada documento e o número de caracteres que devem se sobrepor entre dois documentos consecutivos.

• Cria um armazenamento de vetor a partir dos documentos de amostra chamando o método MongoDBAtlasVectorSearch.fromDocuments . Este método especifica os seguintes parâmetros:

  • O documento de amostra a serem armazenados no reconhecimento de data center vetorial.

  • Modelo de incorporação da Voyage AI como modelo usado para converter texto em incorporações vetoriais para o campo embedding .

  • Sua configuração do cluster 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({ 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);

Salve o arquivo e execute o seguinte comando para carregar seus dados no MongoDB.

node get-started.js

Crie o índice de Vector Search do MongoDB

Para habilitar consultas de pesquisa de vetor em seu armazenamento de vetor, crie um índice do MongoDB Vector Search na coleção langchain_db.test .

node get-started.js

Executar queries no Vector Search

Esta seção demonstra várias queries que você pode executar em seus dados vetorizados. Agora que você criou o índice, adicione o seguinte código à sua função assíncrona para executar queries do Atlas Search vetorial em seus dados.

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

Responda a perguntas sobre seus dados

Esta seção demonstra duas implementações diferentes de RAG usando o MongoDB Vector Search e o LangChain. Agora que você usou a Vector Search do MongoDB para recuperar documentos semanticamente semelhantes, use os exemplos de código a seguir para solicitar que o LLM responda às perguntas dos documentos retornados pela Vector Search do MongoDB .

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

Próximos passos

Para saber como integrar a Vector Search do MongoDB ao LangGraph, consulte Integrar o MongoDB ao LangGraph.js.

O MongoDB também fornece os seguintes recursos para desenvolvedores:

• Repositório do GitHub para desenvolvedores do MongoDB