Integra MongoDB con Mastra

Puede integrar MongoDB con Mastra Para crear agentes de IA. Mastra es un framework de agentes TypeScript de código abierto que proporciona primitivas para crear aplicaciones de IA, incluyendo flujos de trabajo, RAG y evaluaciones.

Importante

Esta integración es Mantenido por la comunidad. Para obtener más información, consulte la documentación de Mastra o el repositorio de GitHub de Mastra.

Overview

Puedes utilizar MongoDB con Mastra para crear agentes de IA. Al combinar MongoDB búsqueda vectorial con el framework de agentes de Mastra, puedes implementar las siguientes capacidades para tus agentes:

Almacene y recupere incrustaciones vectoriales utilizando MongoDB como su base de datos vectorial
Filtra los resultados de tu búsqueda de vectores usando la sintaxis de consulta de MongoDB
Implementar RAG como herramienta en tus agentes
Almacene la memoria de su agente en MongoDB

Instalación y configuración

Para utilizar MongoDB con Mastra, instale el @mastra/mongodb paquete:

npm install @mastra/mongodb

Para comenzar a utilizar Mastra y aprender a crear un proyecto,consulte Instalar Mastra.

Almacenamiento de vectores

MongoDB es una base de datos compatible con Mastra. La MongoDBVector clase permite almacenar y recuperar incrustaciones vectoriales de MongoDB. Puede usar este componente para implementar RAG almacenando incrustaciones de sus datos y recuperándolas mediante MongoDB Vector Search.

Este componente requiere que cree un índice de búsqueda vectorial de MongoDB.

Uso

Para usar el almacén de vectores de MongoDB con Mastra, importe la clase MongoDBVector, cree un objeto con la clase y especifique los detalles de su conexión a MongoDB. Por ejemplo:

import { MongoDBVector } from '@mastra/mongodb'
// Instantiate MongoDB as a vector store
const mongoVector = new MongoDBVector({
  uri: process.env.MONGODB_URI,        // MongoDB connection string
  dbName: process.env.MONGODB_DATABASE // Database name
})

Métodos

Esta sección destaca los métodos más relevantes para trabajar con MongoDB como almacén de vectores. Para obtener una lista completa de métodos, consulte la documentación de Mastra.

Antes de poder buscar en sus incrustaciones, debe crear un índice de búsqueda vectorial en su colección. El parámetro dimension debe coincidir con el número de dimensiones requerido por su modelo de incrustación.

// Create a vector search index
await mongoVector.createIndex({
  indexName: "vector_index",       // Name of the index
  dimension: 1536,                 // Must match your embedding model's dimensions
});

Tras crear un índice, puede almacenar incrustaciones vectoriales con sus metadatos asociados. Para ver un ejemplo completo, consulte el ejemplo de incrustaciones upsert de Mastra.

import { openai } from "@ai-sdk/openai";
import { MongoDBVector } from "@mastra/mongodb";
import { MDocument } from "@mastra/rag";
import { embedMany } from "ai";
// Create a document from text
const doc = MDocument.fromText("Your text content...");
// Split document into chunks
const chunks = await doc.chunk();
// Generate embeddings for each chunk
const { embeddings } = await embedMany({
  values: chunks.map(chunk => chunk.text), // Text content to embed
  model: openai.embedding("text-embedding-3-small"), // Embedding model
});
// Instantiate MongoDB as a vector store
const mongoVector = new MongoDBVector({
  uri: process.env.MONGODB_URI,   // MongoDB connection string
  dbName: process.env.MONGODB_DB_NAME, // Database name
});
// Store vector embeddings with metadata
await mongoVector.upsert({
  indexName: "vector_index",                         // Name of the vector search index
  vectors: embeddings,                               // Array of vector embeddings
  metadata: chunks?.map(chunk => ({ text: chunk.text })), // Associated metadata for each embedding
});

Para recuperar documentos semánticamente similares, primero convierta su consulta en una incrustación y luego consulte el almacén de vectores. Para obtener más información, consulte Recuperación en Mastra.

import { openai } from "@ai-sdk/openai";
import { embed } from "ai";
import { MongoDBVector } from "@mastra/mongodb";
// Convert query to embedding
const { embedding } = await embed({
  value: "What are the main points in the article?",  // Query text
  model: openai.embedding("text-embedding-3-small"), // Embedding model
});
// Instantiate MongoDB as a vector store
const mongoVector = new MongoDBVector({
  uri: process.env.MONGODB_URI,        // MongoDB connection string
  dbName: process.env.MONGODB_DATABASE // Database name
});
// Query the vector store for similar documents
const results = await mongoVector.query({
  indexName: "vector_index", // Name of the vector search index
  queryVector: embedding,    // Query embedding vector
  topK: 10,                  // Number of results to return
});
// Display results
console.log(results);

Filtrado de metadatos

El almacén de vectores MongoDB admite el filtrado de metadatos en los resultados de su consulta de búsqueda de vectores:

Utilice la sintaxis de consulta Mastra, sin limitaciones.
Utilice operadores estándar de comparación, matriz, lógicos y de elementos.
Utilice campos y matrices mezclados en metadatos
Filtro por metadatos y el contenido de los documentos originales

El siguiente ejemplo de uso demuestra la sintaxis de filtrado:

// Query with metadata filters
const results = await mongoVector.query({
  indexName: "vector_index",           // Name of the vector search index
  queryVector: queryVector,            // Query embedding vector
  topK: 10,                            // Number of results to return
  filter: {
    category: "electronics",           // Simple equality filter
    price: { $gt: 100 },               // Numeric comparison
    tags: { $in: ["sale", "new"] },    // Array membership
  },
});

Tip

Para un rendimiento óptimo, cree índices en los campos de metadatos que filtre con frecuencia. Para obtener más información, consulte Índices de búsqueda vectorial de MongoDB.

Para obtener más información, consulta Filtros de metadatos.

RAG con Agentes de IA

Puedes usar MongoDB como un almacén vectorial dentro de agentes Mastra IA para implementar agentic RAG. Esto permite que sus agentes utilicen la búsqueda vectorial de MongoDB como herramienta para ayudar a completar tareas.

Mastra también proporciona una MONGODB_PROMPT constante que puede incluir en las instrucciones de su agente para optimizar el uso de MongoDB para la recuperación. Para obtener más información, consulte Avisos del almacén de vectores.

Uso

El siguiente ejemplo muestra cómo crear un agente de IA con capacidades RAG utilizando MongoDB como almacén de vectores:

import { Agent } from '@mastra/core/agent';
import { openai } from '@ai-sdk/openai';
import { MONGODB_PROMPT } from "@mastra/mongodb";
import { createVectorQueryTool } from "@mastra/rag";
// Create a vector query tool for the agent
const vectorQueryTool = createVectorQueryTool({
  vectorStoreName: "mongoVector",                    // Name of MongoDB vector store
  indexName: "vector_index",                         // Name of Vector Search index
  model: openai.embedding("text-embedding-3-small"), // Embedding model
});
// Define an AI agent with RAG capabilities
export const ragAgent = new Agent({
  name: 'RAG Agent',                 // Agent name
  model: openai('gpt-4o-mini'),      // LLM model
  instructions: `
  Process queries using the provided context. Structure responses to be concise and relevant.
  ${MONGODB_PROMPT}
  `,
  tools: { vectorQueryTool },        // Tools available to the agent
});

Memoria con agentes de IA

Puede usar el sistema de memoria de Mastra con MongoDB como backend de almacenamiento. Esto le permite a su agente recordar interacciones pasadas y usar esa información para tomar decisiones futuras.

Para obtener un tutorial completo, consulte Memoria con MongoDB.

Uso

El siguiente ejemplo demuestra cómo usar la memoria con agentes de IA. Este ejemplo usa memoryOptions para delimitar la recuperación de la solicitud. Establezca lastMessages: 5 para limitar la recuperación basada en la actualidad. Use semanticRecall para recuperar los topK: 3 mensajes más relevantes, incluyendo messageRange: 2 mensajes adyacentes para el contexto de cada coincidencia.

import "dotenv/config";
 
import { mastra } from "./mastra";
 
const threadId = "123";
const resourceId = "user-456";
 
const agent = mastra.getAgent("mongodbAgent");
 
const message = await agent.stream("My name is Mastra", {
  memory: {
    thread: threadId,
    resource: resourceId
  }
});
 
await message.textStream.pipeTo(new WritableStream());
 
const stream = await agent.stream("What's my name?", {
  memory: {
    thread: threadId,
    resource: resourceId
  },
  memoryOptions: {
    lastMessages: 5,
    semanticRecall: {
      topK: 3,
      messageRange: 2
    }
  }
});
 
for await (const chunk of stream.textStream) {
  process.stdout.write(chunk);
}

Recursos adicionales

Para obtener más información sobre el uso de Mastra con MongoDB, consulte:

Volver

Compila un agente de IA

Amazon Bedrock