Pesquisa avançada com servidor corporativo

Visão Geral da Solução

Mesmo com a acelerada adesão à nuvem, muitos clientes optam por uma infraestrutura autogerenciada e implantações on-prem, especialmente em setores altamente regulamentados. Por exemplo, de acordo com esta pesquisa, 93% do governo usa implantações on-prem, seguidos por 91% das organizações do setor de informática e 90% do setor financeiro. Além disso, muitas PME, como lojas de departamento ou cadeias de mercearias regionais, usam implantações on-prem, pois o alto custo para adotar a arquitetura de nuvem é uma limitação financeira.

Embora a infraestrutura autogerenciada ofereça flexibilidade, controle de conformidade e soberania de dados, ela apresenta desafios para as organizações que buscam implementar soluções alimentadas por IA. Alguns desses desafios incluem:

• Complexidade arquitetônica: as empresas geralmente combinam mecanismos de pesquisa separados e bancos de dados vetoriais para obter funcionalidades avançadas de pesquisa, como a pesquisa vetorial.

• Sobrecarga operacional: as equipes podem ter dificuldade em sincronizar tecnologias separadas, gerenciar recursos variados e manter fluxos de trabalho consistentes em vários sistemas.

Para resolver esses obstáculos, o MongoDB introduziu o pesquisa e pesquisa vetorial com o MongoDB Enterprise servidor. Essas funcionalidades de pesquisa permitem:

• Crie aplicativos de IA da próxima geração em qualquer infraestrutura: reduza a complexidade arquitetônica, o que facilita o desenvolvimento de soluções alimentadas por IA e elimina a necessidade de várias tecnologias de finalidade única.

• Aproveite uma experiência consistente em todos os lugares: use a mesma MQL API, independentemente de onde o aplicativo esteja conectado. Isso reduz o Atlas e oferece flexibilidade ao alternar entre ambientes de produção e desenvolvimento.

Essa solução apresenta uma demonstração que usa o MongoDB Search e a pesquisa vetorial para ajudar os usuários a descobrir produtos em um supermercado usando a pesquisa de texto completo ou a pesquisa semântica alimentada por incorporações vetoriais. Ele inclui pré-requisitos, requisitos de arquitetura e instruções passo a passo para executar a demonstração em um ambiente com o servidor MongoDB Enterprise e nós de pesquisa.

figura 1. A página de destino da demonstração

Arquitetura de referência

Para usar as funcionalidades de pesquisa avançada com o servidor Enterprise, você deve implantar os nós do MongoDB Search e da pesquisa vetorial em um cluster Kubernetes. Isso permite a pesquisa de texto completo e a pesquisa semântica alimentadas por incorporações vetoriais, permitindo que os usuários encontrem itens com base em descrições ou similaridade semântica.

Você não precisa migrar seu banco de dados existente. Use o MongoDB Enterprise Edition executando o MongoDB 8.0.10 versão ou posterior, dentro ou fora de um cluster Kubernetes. O operador Kubernetes gerencia esses nós de pesquisa e os conecta com segurança ao cluster de banco de dados, independentemente da sua localização de implantação.

Em resumo, você pode usar as seguintes abordagens para integrar o MongoDB Search e a pesquisa vetorial com o Enterprise Server:

1. MongoDB Enterprise Edition implantado dentro do Kubernetes

2. MongoDB Enterprise Edition implantado fora do Kubernetes

Ambas as arquiteturas de implantação exigem nós de pesquisa MongoDB e pesquisa vetorial implantados no Kubernetes. As seções a seguir descrevem cada abordagem.

Instalar pesquisa com MongoDB Enterprise Edition Dentro do Kubernetes

Essa opção de implantação configura os nós MongoDB Search e pesquisa vetorial diretamente no cluster Kubernetes juntamente com instâncias do servidor MongoDB Enterprise, conforme usado na demonstração. Essa implantação garante operações integradas e simplifica o gerenciamento ao manter todos os componentes no mesmo ambiente. A imagem abaixo ilustra esta implantação.

figura 2. MongoDB Enterprise servidor dentro do Kubernetes

Nesta solução, o cluster do Kubernetes hospeda o Enterprise Server, os nós de pesquisa e o aplicativo de inventário. Essa arquitetura simplifica o gerenciamento e garante a troca eficiente de dados entre componentes.

Para obter instruções passo a passo sobre como configurar nós de pesquisa com uma configuração interna do Servidor Enterprise, consulte Instalar e usar a pesquisa com o MongoDB Enterprise Edition.

Instalar pesquisa com MongoDB Enterprise Edition fora do Kubernetes

Esta opção de implantação configura os nós MongoDB pesquisa e pesquisa vetorial dentro do Kubernetes, que se conectam a um conjunto de réplicas do Enterprise Server implantado fora do cluster do Kubernetes. Você pode usar essa abordagem se tiver requisitos de infraestrutura ou preferências operacionais fora do Kubernetes. A imagem abaixo ilustra esta implantação.

figura 3. MongoDB Enterprise servidor fora do Kubernetes

Essa configuração permite integrar funcionalidades de pesquisa avançada sem alterar a infraestrutura existente do servidor empresarial.

Para obter instruções passo a passo sobre como instalar os nós de pesquisa do MongoDB e de pesquisa vetorial com uma configuração de servidor externo da MongoDB Enterprise Edition, consulte Instalar e usar a pesquisa do MongoDB e a pesquisa vetorial com a MongoDB Enterprise Edition externa.

Construir a solução

Siga as etapas abaixo para configurar e executar a solução.

1

Implantar nós do MongoDB pesquisa e pesquisa vetorial

Siga as etapas no tutorial Instalar e usar a pesquisa com MongoDB Enterprise Edition para implantar os nós de pesquisa e pesquisa vetorial do MongoDB.

2

Clonar o repositório

Para a exportação de dados necessária e a configuração do aplicativo, baixe o repositório de demonstração:

git clone https://github.com/mongodb-industry-solutions/retail-unified-commerce

Go para o diretório do arquivo de despejo:

cd ./retail-unified-commerce/docs/setup

3

Importar os dados de demonstração

Importe os dados de inventário de amostra de armazenar para a implantação do MongoDB.

Execute o seguinte comando para recuperar a string de conexão. Substitua <SECRET_NAME> pelo nome secret do Kubernetes apropriado gerado durante a implantação:

kubectl get secret -n ${MDB_NS} <SECRET_NAME> -o yaml

Este comando imprime os metadados secretos e seu conteúdo codificado. Copie o valor connectionStringStandard e execute o seguinte comando para obter a string de conexão:

echo "<Base64EncodedConnectionString>" | base64 --decode

Execute o seguinte comando para restaurar o banco de dados a partir da pasta de despejo do collections:

mongorestore --uri "<CONNECTION_STRING>" ./collections

4

Criar índices de MongoDB Search e Vector Search

Abra o mongosh com sua string de conexão para conectar ao seu cluster:

mongosh "<CONNECTION_STRING>"
use retail-unified-commerce

Executar o seguinte comando para criar o índice de pesquisa MongoDB:

db.products.createSearchIndex("product_atlas_search", {
   "mappings": {
      "dynamic": false,
      "fields": {
         "brand": {
            "type": "string"
         },
         "category": {
            "type": "string"
         },
         "inventorySummary": {
            "fields": {
               "storeObjectId": {
                  "type": "objectId"
               }
            },
            "type": "document"
         },
         "productName": {
            "type": "string"
         },
         "subCategory": {
            "type": "string"
         }
      }
   }
})

Executar o seguinte comando para criar o índice do MongoDB pesquisa vetorial:

db.products.createSearchIndex({
   name: "product_text_vector_index",
   type: "vectorSearch",
   definition: {
      fields: [
         {
            type: "vector",
            path: "textEmbeddingVector",
            numDimensions: 1024,
            similarity: "cosine"
         },
         {
            type: "filter",
            path: "inventorySummary.storeObjectId"
         },
         {
            type: "filter",
            path: "inventorySummary.inStock"
         }
      ]
   }
})

Execute o seguinte comando para confirmar que ambos os índices foram criados corretamente. Se for bem-sucedido, o comando retornará metadados para product_atlas_search e product_text_vector_index.

JSON.stringify(db.runCommand({listSearchIndexes: "products"}), null, 2)

Teste seus índices usando a seguinte query:

db.products.aggregate([
   {
      "$search": {
         "index": "product_atlas_search",
         "compound": {
            "should": [
               {
                  "text": {
                     "query": "Chicken Masala",
                     "path": ["productName", "brand", "category", "subCategory"],
                     "fuzzy": { "maxEdits": 2 },
                  }
               }
            ]
         },
      }
   },
   {
      $project: {
         productName: 1,
         score: { $meta: "searchScore" }
      }
   },
   {
      $limit: 2
   }
])

A query retorna uma lista de nomes de produtos e sua pontuação de pesquisa:

[
   {
      _id: ObjectId("685bfe2d3d832cf7e1614edc"),
      productName: "Chicken Masala",
      score: 8.192384719848633,
   },
   {
      _id: ObjectId("685bfe2e3d832cf7e16159fe"),
      productName: "Shahi Chicken Masala",
      score: 7.7956156730651855,
   },
];

5

Configurar e executar a demonstração

Crie um arquivo .env no diretório backend/advanced-search-ms e outro no diretório frontend. Você pode encontrar um arquivo .env.template nestes diretórios. Atualize os espaços reservados com a string de conexão que você recuperou anteriormente.

Consulte o README do repositório GitHub para obter contexto adicional e configurações opcionais para configurar.

Você pode implantar a demonstração localmente ou no Kubernetes.

Execute localmente

Implantar usando o Kubernetes

Execute o seguinte código:

make build

Certifique-se de que seus serviços de frontend e backend estejam acessíveis no localhost usando seu método preferido. Em seguida, abra seu navegador no http://localhost:3000/product-inventory.

Execute o backend e o frontend dentro do Kubernetes cluster usando as imagens Docker criadas para a demonstração. Siga estas etapas:

1. Crie e envie imagens do Docker

Crie e envie as imagens de backend e frontend para seu registro de contêiner executando os seguintes comandos:

#Backend
docker build --platform linux/amd64 -t retail-backend:latest ./backend/advanced-search-ms
docker tag retail-backend:latest <YOUR_REGISTRY>/retail-backend:latest
docker push <YOUR_REGISTRY>/retail-backend:latest
#Frontend
docker build --platform linux/amd64 -t retail-frontend:latest ./frontend
docker tag retail-frontend:latest <YOUR_REGISTRY>/retail-frontend:latest
docker push <YOUR_REGISTRY>/retail-frontend:latest

O sinalizador --platform linux/amd64 pode ser exigido dependendo da arquitetura da sua máquina.

2. Crie os secrets do Kubernetes

Armazene valores sensíveis em um secret do Kubernetes denominado retail-secrets.yaml dentro da pasta retail-unified-commerce/k8s. Não faça confirmação de credenciais reais no controle de origem. Abaixo está um modelo de exemplo :

# retail-unified-commerce/k8s/retail-secrets.yaml
apiVersion: v1
kind: Secret
metadata:
  name: retail-secrets
  namespace: default
type: Opaque
data:
  NEXT_PUBLIC_GOOGLE_MAPS_API_KEY:
  VOYAGE_API_KEY:
stringData:
  MONGODB_URI: <YOUR_CONNECTION_STRING>
  DB_NAME: "retail-unified-commerce"
  NEXT_PUBLIC_COLLECTION_PRODUCTS: "products"
  NEXT_PUBLIC_COLLECTION_INVENTORY: "inventory"
  NEXT_PUBLIC_COLLECTION_STORES: "stores"
  SEARCH_INDEX: "product_atlas_search"
  NEXT_PUBLIC_BACKEND_ENDPOINT: "<YOUR_BACKEND_ENDPOINT>"
  NEXT_PUBLIC_ENABLE_ATLAS_SEARCH: "true"
  NEXT_PUBLIC_ENABLE_VECTOR_SEARCH: "true"
  NEXT_PUBLIC_ENABLE_HYBRID_SEARCH: "true"
  NEXT_PUBLIC_ENABLE_FULLTEXT_SEARCH: "true"
  MONGODB_DATABASE: "retail-unified-commerce"
  PRODUCTS_COLLECTION: "products"
  SEARCH_TEXT_INDEX: "product_atlas_search"
  SEARCH_VECTOR_INDEX: "product_text_vector_index"
  NEXT_PUBLIC_SEARCH_META_INDEX: "product_atlas_search_meta"
  EMBEDDING_FIELD_NAME: "textEmbeddingVector"
  VOYAGE_API_URL: "https://api.voyageai.com/v1"
  VOYAGE_MODEL: "voyage-3-large"

Aplique os segredos ao seu cluster:

kubectl apply -f k8s/retail-secrets.yaml

3. Implante o backend e o frontend

Coloque o modelo backend-deployment.yaml no seu diretório /k8s:

# retail-unified-commerce/k8s/backend-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: retail-backend
spec:
  replicas: 2
  selector:
    matchLabels:
      app: retail-backend
  template:
    metadata:
      labels:
        app: retail-backend
    spec:
      containers:
      - name: backend
        image: <YOUR_REGISTRY>/retail-backend:latest
        ports:
        - containerPort: 8000
        envFrom:
        - secretRef:
          name: retail-secrets
---
apiVersion: v1
kind: Service
metadata:
  name: retail-backend-service
spec:
  type: LoadBalancer
  selector:
    app: retail-backend
  ports:
  - port: 80
    targetPort: 8000

Coloque o modelo frontend-deployment.yaml no seu diretório /k8s:

# retail-unified-commerce/k8s/frontend-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: retail-frontend
spec:
  replicas: 2
  selector:
    matchLabels:
      app: retail-frontend
  template:
    metadata:
      labels:
        app: retail-frontend
    spec:
      containers:
      - name: frontend
        image: <YOUR_REGISTRY>/retail-frontend:latest
        ports:
        - containerPort: 3000
        envFrom:
        - secretRef:
          name: retail-secrets
---
apiVersion: v1
kind: Service
metadata:
  name: retail-frontend-service
spec:
  type: LoadBalancer
  selector:
    app: retail-frontend
  ports:
  - port: 80
    targetPort: 3000

Aplique suas implantações do Kubernetes:

kubectl apply -f k8s/backend-deployment.yaml
kubectl apply -f k8s/frontend-deployment.yaml

Verifique suas implantações:

kubectl get pods -o wide
kubectl get svc -o wide

Aguarde até que os serviços de frontend e backend tenham um EXTERNAL-IP atribuído.

4. Acesse a demonstração

Quando o IP externo aparecer para o serviço de frontend, abra-o usando o seguinte link: http://<EXTERNAL-IP>/product-inventory.

6

Explore as funcionalidades de pesquisa da demonstração

Selecione a opção MongoDB pesquisa e insira queries que não correspondam exatamente aos nomes do produto. Por exemplo, use um termo como máscara Facial de chá verde ou um erro de digitação como cukie. Essas consultas demonstram a capacidade do sistema de retornar resultados relevantes quando a entrada é imprecisa.

figura 4. Resultado da pesquisa para máscara de chá verde

Alterne para a opção MongoDB pesquisa vetorial para experimentar a compreensão semântica. Use queries descritivas ou baseadas em intenção, como um presente para uma garota adolescente ou um petisco apimentado com alto valor protéico. O sistema mostra resultados alinhados com o significado da sua query, não apenas com as palavras usadas.

figura 5. Resultado de pesquisa vetorial para presente para uma menor

Em ambos os resultados, você pode visualizar a pontuação da pesquisa exibido no canto superior esquerdo de cada cartão de produto. Essa pontuação indica a relevância do resultado para sua query.

Principais Aprendizados

• A aprovação no local tem importância estratégia: as implantações no local permanecem críticas para setores e organizações que priorizam a soberania e o controle dos dados. Essa pré-visualização pública permite que as organizações adotem IA em seus ambientes no local, garantindo que elas se mantenham concorrenciais e atendam aos requisitos de compliance.

• A pilha de tecnologia simplificada acelera a adoção de IA: o MongoDB Pesquisa e a pesquisa vetorial com o Enterprise servidor permitem aplicativos avançados de IA ao consolidar diversas tecnologias, reduzir a complexidade arquitetônica e permitir querys de pesquisa inteligentes sem migrar dados operacionais.

• Funcionalidades avançadas de pesquisa aprimoram a experiência do usuário: a pesquisa de texto completo e a pesquisa vetorial refinam a forma como os usuários exploram e acessam informações, proporcionando experiências mais intuitivas em diferentes setores.

Autores

• Angie Guemes Estrada, MongoDB

• Ricardo Leal, MongoDB

• Prashant Juttukonda, MongoDB

Saiba mais

• Para implantar a MongoDB pesquisa e a pesquisa vetorial em seu cluster Kubernetes, visite Implantar a MongoDB pesquisa e a pesquisa vetorial.

• Para saber mais sobre os recursos de pesquisa e pesquisa vetorial para uso com o MongoDB Community Edition e o MongoDB Enterprise Server, leia o Potencialize Aplicativos Autogerenciados com Funcionalidades de Pesquisa e Pesquisa Vetorial.

• Para descobrir como o MongoDB impulsiona a Inovação no Varejo, visite MongoDB para Varejo.