Integra MongoDB con Mastra

Puede integrar MongoDB con Mastra para compilar agentes de IA. Mastra es un framework de agentes de código abierto de TypeScript que proporciona los elementos básicos para crear aplicaciones de IA, incluyendo workflows, RAG y evaluaciones.

Importante

Esta integración está mantenida por la comunidad. Para obtener más información, consulta la documentación de Mastra o el repositorio de Mastra en 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 usar MongoDB con Mastra, instala el paquete @mastra/mongodb:

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 crees un Índice de búsqueda vectorial 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 resalta los métodos más relevantes para trabajar con MongoDB como almacén de vectores. Para obtener una lista completa de métodos, consulta la documentación de Mastra.

Antes de poder buscar en tus embeddings, debes crear un índice de búsqueda vectorial en tu colección. El parámetro dimension debe coincidir con el número de dimensiones requeridas por su modelo de integració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
Utilizar campos anidados y arreglos en los metadatos
Filtrar en los 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, crea índices en los campos de metadatos que filtras con frecuencia. Para obtener más información, consulta Í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 vector de almacenamiento en Mastra IA agentes para implementar RAG agentic. Esto permite que tus agentes utilicen la búsqueda vectorial de MongoDB como una 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 vectorial:

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 aprender más sobre cómo usar Mastra con MongoDB, consulta:

Volver

Compila un agente de IA

Amazon Bedrock