Integra MongoDB con Mastra

Puedes 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, ve documentación de Mastra o el repositorio Mastra GitHub.

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 tus resultados de búsqueda vectorial usando la sintaxis de consultas 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 empezar con Mastra y aprender a crear un proyecto, consulte Instalar Mastra.

Almacenamiento de vectores

MongoDB es una base de datos soportada en Mastra. La clase MongoDBVector te permite almacenar y recuperar vectores de embeddings desde MongoDB. Puedes usar este componente para implementar RAG almacenando embeddings de tus datos y recuperándolos usando MongoDB Vector Search.

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

Uso

Para usar la base de datos vectorial de MongoDB con Mastra, importa la clase MongoDBVector, crea un objeto con la clase y especifica los detalles de conexión con 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
});

Después de crear un índice, se pueden almacenar incrustaciones vectoriales con metadatos asociados. Para ver un ejemplo completo, consulte Mastra inserción embeddings ejemplo.

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 convierte tu query en una incrustación y luego consulta el almacén de vectores. Para aprender más información, consulta 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 la consulta de búsqueda vectorial:

Utiliza la sintaxis de query de Mastra, sin limitaciones.
Usa operadores estándar de comparación, de arreglo, 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 constante MONGODB_PROMPT que puedes incluir en tus instrucciones de agente para optimizar cómo utiliza el agente MongoDB para la recuperación. Para obtener más información, consulte Prompts de Vector Store.

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

Puedes utilizar el sistema de memoria de Mastra con MongoDB como backend de almacenamiento. Esto permite que el agente recuerde interacciones pasadas y utilice esa información para tomar decisiones futuras.

Para un tutorial completo, consulta Memoria con MongoDB.

Uso

El siguiente ejemplo demuestra cómo usar la memoria con agentes de IA. Este ejemplo usa memoryOptions para definir el alcance del recordatorio para la solicitud. Establecer lastMessages: 5 para limitar la recuperación basada en la recencia. Utiliza semanticRecall para obtener los topK: 3 mensajes más relevantes, incluyendo messageRange: 2 mensajes vecinos para obtener contexto en torno a 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