Crie uma arquitetura multilocatário para a Vector Search do MongoDB

Uma coleção para todos os locatários

Recomendamos armazenar todos os dados do locatário em uma única coleção, bem como em um único banco de dados e cluster. Você pode distinguir entre inquilinos incluindo um tenant_id campo dentro de cada documento. Este campo pode ser qualquer identificador exclusivo para o locatário, como UUID ou um nome de locatário. Você pode usar esse campo como um pré-filtro em seus índices e consultas do MongoDB Vector Search .

Essa abordagem centralizada oferece os seguintes benefícios:

• Fácil de modelar e dimensionar.

• Simplifica as operações de manutenção.

• Roteamento eficiente de query por meio de pré-filtragem por tenant_id.

  Observação

  Você tem a garantia de não servir locatários que não correspondam a este filtro.

Uma coleção por locatário ou um banco de dados por locatário

Não recomendamos armazenar cada locatário em uma coleção ou banco de dados separado pelos seguintes motivos:

• Impacto no desempenho: essa abordagem pode levar à variação das cargas de fluxo de alterações, dependendo do número de coleções, o que pode impactar negativamente o desempenho e os recursos de monitoramento.

• Sem isolamento adicional: As garantias de isolamento de dados no Atlas se aplicam no nível do banco de dados. O uso de coleções separadas dentro do mesmo banco de dados não oferece nenhum benefício adicional de isolamento de dados. O uso de bancos de dados separados introduz complexidade operacional sem vantagens de segurança significativas para a maioria dos casos de uso.

Em vez disso, use uma coleção para todos os locatários. Para um exemplo de como migrar de um modelo de coleção por locatário para um modelo de coleção única, veja Migrando de um modelo de coleção por locatário.

Discrepâncias de tamanho do locatário

Se você tiver muitos locatários com relativamente poucos vetores cada, ou se tiver problemas de desempenho devido à distribuição desigual de dados (alguns locatários grandes e muitos locatários pequenos), considere as estratégias a seguir.

{
  "fields": [
    {
      "type": "vector",
      "path": "<fieldToIndex>",
      "numDimensions": <numberOfDimensions>,
      "similarity": "euclidean | cosine | dotProduct",
      "indexingMethod": "flat"
    },
    {
      "type": "filter",
      "path": "tenant_id"
    }
  ]
}

db.createView(
  "<viewName>",
  "<collectionName>",
  [
    {
      "$match": {
        "tenant_id": "<largeTenantId>"
      }
    }
  ]
)

db.createView(
  "<viewName>",
  "<collectionName>",
  [
    {
      "$match": {
        "tenant_id": {
          "$nin": [ "<largeTenantId1>", "<largeTenantId2>", ... ]
        }
      }
    }
  ]
)

Muitos locatários grandes

Se você tiver muitos locatários, cada um com um grande número de vetores, considere usar um sistema baseado em partições distribuindo dados entre fragmentos.

Você pode usar o campo tenant_id como uma chave de fragmento para distribuir os dados em faixas específicas com base no ID do locatário. Para obter mais informações, consulte Fragmentação à distância.

Migrando de um modelo de coleção por locatário

Para migrar de um modelo de coleção por locatário para um modelo de coleção única, processe cada coleção de locatário e insira os documentos em uma nova coleção.

import { MongoClient } from 'mongodb';
const uri = "<connectionString>"; 
const sourceDbName = "<sourceDatabaseName>"; 
const targetDbName = "<targetDatabaseName>"; 
const targetCollectionName = "<targetCollectionName>";
async function migrateCollections() {
 const client = new MongoClient(uri);
 try {
     await client.connect();
     const sourceDb = client.db(sourceDbName);
     const targetDb = client.db(targetDbName);
     const targetCollection = targetDb.collection(targetCollectionName);
     const collections = await sourceDb.listCollections().toArray();
     console.log(`Found ${collections.length} collections.`);
     const BATCH_SIZE = 1000; // Define a suitable batch size based on your requirements
     let totalProcessed = 0;
     for (const collectionInfo of collections) {
         const collection = sourceDb.collection(collectionInfo.name);
         let documentsProcessed = 0;
         let batch = [];
         const tenantId = collectionInfo.name; // Uses the collection name as the tenant_id
         const cursor = collection.find({});
         for await (const doc of cursor) {
             doc.tenant_id = tenantId; // Adds a tenant_id field to each document
             batch.push(doc);
             if (batch.length >= BATCH_SIZE) {
                 await targetCollection.insertMany(batch);
                 totalProcessed += batch.length;
                 documentsProcessed += batch.length;
                 console.log(`Processed ${documentsProcessed} documents from ${collectionInfo.name}. Total processed: ${totalProcessed}`);
                 batch = [];
             }
         }
         if (batch.length > 0) {
             await targetCollection.insertMany(batch);
             totalProcessed += batch.length;
             documentsProcessed += batch.length;
             console.log(`Processed ${documentsProcessed} documents from ${collectionInfo.name}. Total processed: ${totalProcessed}`);
         }
     }
     console.log(`Migration completed. Total documents processed: ${totalProcessed}`);
 } catch (err) {
     console.error('An error occurred:', err);
 } finally {
     await client.close();
 }
}
await migrateCollections().catch(console.error);