Búsqueda avanzada con el servidor Enterprise

Descripción general de la solución

A medida que la adopción de la nube se acelera, muchos clientes optan por infraestructura autogestionada e implementaciones locales, especialmente en industrias altamente reguladas. Por ejemplo, según esta encuesta, el 93% de los organismos gubernamentales utiliza implementaciones locales, seguido por el 91% de las organizaciones en la industria de TI y el 90% en la industria financiera. Además, muchas pymes, como tiendas boutique o cadenas de supermercados regionales, utilizan implementaciones locales, ya que el alto costo de adoptar la arquitectura en la nube representa un obstáculo financiero.

Si bien la infraestructura autogestionada proporciona flexibilidad, control de cumplimiento y soberanía de datos, presenta desafíos para las organizaciones que buscan implementar soluciones impulsadas por IA. Algunos de estos desafíos incluyen:

• Complejidad arquitectónica: Las empresas a menudo combinan motores de búsqueda separados y bases de datos vectoriales para lograr capacidades de búsqueda avanzadas, como la búsqueda vectorial.

• Desbordamiento operativo: Los equipos pueden tener dificultades para sincronizar tecnologías separadas, gestionar la variedad de recursos y mantener flujos de trabajo coherentes en múltiples sistemas.

Para abordar estos desafíos, MongoDB introdujo Búsqueda y búsqueda vectorial con MongoDB Enterprise servidor. Estas capacidades de búsqueda te permiten:

• Construya aplicaciones de IA de próxima generación en cualquier infraestructura: Reduzca la complejidad arquitectónica, lo que facilita el desarrollo de soluciones impulsadas por IA y elimina la necesidad de múltiples tecnologías de un solo propósito.

• Disfruta de una experiencia coherente en todas partes: Utiliza la misma API MQL independientemente de dónde esté conectada la aplicación. Esto reduce la fricción y proporciona flexibilidad al moverse entre entornos de producción y desarrollo.

Esta solución presenta una demo que utiliza MongoDB Search y búsqueda vectorial para ayudar a los usuarios a descubrir productos en un supermercado, ya sea utilizando búsqueda de texto completo o búsqueda semántica potenciada por incrustaciones vectoriales. Incluye prerrequisitos, requerimientos de arquitectura e instrucciones paso a paso para ejecutar la demostración en un entorno con MongoDB Enterprise Server y nodos de búsqueda.

Figura 1. La página de inicio de la demo

Arquitectura de referencia

Para utilizar funciones de búsqueda avanzada con Enterprise Server, debes desplegar los nodos de MongoDB Search y búsqueda vectorial en un clúster de Kubernetes. Esto permite una búsqueda de texto completo y semántica impulsada por incrustaciones de vectores, lo que permite a los usuarios encontrar artículos basándose en descripciones o similitudes semánticas.

No es necesario migrar tu base de datos actual. Utiliza MongoDB Enterprise Edition ejecutando MongoDB 8.0.10 versión o posterior, ya sea dentro o fuera de un clúster de Kubernetes. El operador de Kubernetes gestiona estos nodos de búsqueda y los conecta de forma segura a tu clúster de base de datos, independientemente de su ubicación de implementación.

En resumen, puedes usar los siguientes enfoques para integrar MongoDB Search y búsqueda vectorial con Enterprise servidor:

1. MongoDB Enterprise Edition desplegada dentro de Kubernetes

2. MongoDB Enterprise Edition implementado fuera de Kubernetes

Ambas arquitecturas de implementación requieren que los nodos de MongoDB Search y búsqueda vectorial estén implementados dentro de Kubernetes. Las siguientes secciones describen cada enfoque.

Instalar Search con MongoDB Enterprise Edition dentro de Kubernetes

Esta opción de implementación configura los nodos de MongoDB Search y Búsqueda Vectorial directamente dentro del clúster de Kubernetes, junto con las instancias de MongoDB Enterprise servidor, como se utiliza en la demostración. Esta implementación garantiza operaciones integradas y simplifica la gestión al mantener todos los componentes en el mismo entorno. La imagen a continuación ilustra esta implementación.

Figura 2. MongoDB Enterprise servidor dentro de Kubernetes

En esta solución, el clúster de Kubernetes aloja Enterprise Server, los nodos de búsqueda y la aplicación de inventario. Esta arquitectura simplifica la gestión y garantiza un intercambio eficiente de datos entre los componentes.

Para obtener instrucciones paso a paso sobre cómo configurar nodos de búsqueda con una configuración interna de servidor Enterprise, consulta Instalar y usar Búsqueda con MongoDB Enterprise Edition.

Instalar búsqueda con MongoDB Enterprise Edition fuera de Kubernetes

Esta opción de implementación configura los nodos de MongoDB Search y búsqueda vectorial dentro de Kubernetes, los cuales se conectan a un set de réplicas de Enterprise servidor implementado fuera del clúster de Kubernetes. Puede utilizar este enfoque si tiene requisitos de infraestructura o preferencias operativas fuera de Kubernetes. La imagen a continuación ilustra esta implementación.

Figura 3. Servidor MongoDB Enterprise fuera de Kubernetes

Esta configuración te permite integrar capacidades avanzadas de búsqueda sin modificar tu infraestructura de Enterprise servidor existente.

Para obtener instrucciones paso a paso sobre cómo instalar nodos de MongoDB Search y búsqueda vectorial con una configuración de servidor empresarial externa, consulta Instala y usa MongoDB Search y búsqueda vectorial con MongoDB Enterprise Edition externo.

Compilar la solución

Sigue los siguientes pasos para configurar y ejecutar la solución.

1

Despliegue nodos de MongoDB Search y búsqueda vectorial

Sigue los pasos en el tutorial Instalar y utilizar la búsqueda con MongoDB Enterprise Edition para implementar los nodos de MongoDB Search y búsqueda vectorial.

2

Clona el repositorio

Para el volcado de datos necesarios y la configuración de la aplicación, descarga el repositorio de demostración

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

Ir al directorio del archivo de vaciado:

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

3

Importa los datos de demostración

Importa los datos de muestra del inventario del supermercado a tu implementación de MongoDB.

Ejecute el siguiente comando para recuperar la cadena de conexión. Reemplace <SECRET_NAME> por el nombre secreto de Kubernetes adecuado generado durante la implementación:

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

Este comando imprime los metadatos secretos y su contenido codificado. Copia el valor de connectionStringStandard y ejecuta el siguiente comando para obtener la cadena de conexión:

echo "<Base64EncodedConnectionString>" | base64 --decode

Ejecute el siguiente comando para restaurar la base de datos de la carpeta de vaciado collections:

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

4

Crea índices de búsqueda de MongoDB y Vector Search

Abre mongosh con tu cadena de conexión para conectarte a tu clúster:

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

Ejecute el siguiente comando para crear el índice de búsqueda de 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"
         }
      }
   }
})

Ejecuta el siguiente comando para crear el índice MongoDB Vector Search:

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"
         }
      ]
   }
})

Ejecuta el siguiente comando para confirmar que ambos índices se han creado correctamente. Si tiene éxito, el comando devuelve metadatos para product_atlas_search y product_text_vector_index.

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

Pruebe sus índices utilizando la siguiente 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
   }
])

La query devuelve una lista de nombres de productos y su puntuación de búsqueda:

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

5

Configura y ejecuta la demo

Cree un archivo .env en el directorio backend/advanced-search-ms y otro en el directorio frontend. Puedes encontrar un archivo .env.template en estos directorios. Actualiza los marcadores de posición con la cadena de conexión que recuperaste anteriormente.

Consulta el README del repositorio de GitHub para obtener contexto adicional y configuraciones opcionales de instalación.

Puedes implementar la demostración localmente o en Kubernetes.

Ejecutar localmente

Realice la implementación usando Kubernetes

Ejecute el siguiente código:

make build

Asegúrate de que tus servicios frontend y backend sean accesibles en localhost utilizando tu método preferido. Luego, abre tu navegador en http://localhost:3000/product-inventory.

Ejecuta el backend y frontend dentro de tu clúster de Kubernetes utilizando las imágenes de Docker creadas para la demostración. Sigue estos pasos:

1. Compilar y enviar imágenes Docker

Compile y expulse las imágenes del backend y frontend en su registro de contenedores ejecutando los siguientes 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

La bandera --platform linux/amd64 puede ser requerida dependiendo de la arquitectura de tu máquina.

2. Crea los secretos de Kubernetes

Almacene los valores confidenciales en un archivo de secretos de Kubernetes denominado retail-secrets.yaml dentro de la carpeta retail-unified-commerce/k8s. No confirmes las credenciales reales al control de código fuente. A continuación se muestra una plantilla de ejemplo:

# 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"

Aplica los secretos a tu clúster:

kubectl apply -f k8s/retail-secrets.yaml

3. Implementa el backend y el frontend

Coloca la plantilla backend-deployment.yaml en tu directorio /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

Coloca la plantilla frontend-deployment.yaml en tu directorio /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 sus implementaciones de Kubernetes:

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

Verifica tus implementaciones:

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

Espera hasta que los servicios frontend y backend tengan asignado un EXTERNAL-IP.

4. Accede a la demo

Una vez que aparezca la IP externa para el servicio frontend, ábrela usando el siguiente enlace: http://<EXTERNAL-IP>/product-inventory.

6

Explora las capacidades de búsqueda de la demo

Selecciona la opción MongoDB Search e ingresa queries que no coincidan exactamente con los nombres de productos. Por ejemplo, introduce un término como mascarilla facial de té verde o un error ortográfico como cukie. Estas queries demuestran la capacidad del sistema para mostrar resultados relevantes cuando los datos de entrada son imprecisos.

Figura 4. Resultado de búsqueda de mascarilla facial de té verde

Cambie a la opción MongoDB Vector Search para experimentar la comprensión semántica. Usa términos descriptivos o basados en la intención como un regalo para una chica adolescente o bocadillo picante alto en proteínas. El sistema muestra resultados alineados con el significado de tu query, no solo con las palabras utilizadas.

Figura 5. Resultado de búsqueda vectorial para regalo para una adolescente

En ambos resultados, puedes ver la puntuación de búsqueda mostrada en la esquina superior izquierda de cada tarjeta de producto. Esta puntuación indica la relevancia del resultado para tu query.

Lecciones clave

• La adopción on-premises tiene una importancia estratégica: Las implementaciones on-premises siguen siendo críticas para industrias y organizaciones que priorizan la soberanía de los datos y el control. Esta vista previa pública permite a las organizaciones adoptar la IA en sus entornos on-premises, garantizando que sigan siendo competitivas y cumplan con los requisitos de cumplimiento.

• La pila tecnológica simplificada acelera la adopción de IA: MongoDB Search y búsqueda vectorial con Enterprise servidor habilitan potentes aplicaciones de IA al consolidar tecnologías diversas, reducir la complejidad arquitectónica y permitir consultas de búsqueda inteligentes sin migrar datos operativos.

• Las capacidades de búsqueda avanzada mejoran la experiencia del usuario: la búsqueda de texto completo y la búsqueda vectorial refinan la forma en que los usuarios exploran y acceden a la información, impulsando experiencias más intuitivas en diferentes industrias.

Autores

• Angie Guemes Estrada, MongoDB

• Rodrigo Leal, MongoDB

• Prashant Juttukonda, MongoDB

Obtén más información

• Para implementar MongoDB Search y búsqueda vectorial en tu clúster de Kubernetes, visita Implementa MongoDB Search y búsqueda vectorial.

• Para conocer las capacidades de búsqueda y búsqueda vectorial que se pueden usar con MongoDB Community Edition y MongoDB Enterprise Server, leer Supercarga tus apps autogestionadas con capacidades de búsqueda y búsqueda vectorial.

• Para descubrir cómo MongoDB impulsa la innovación en el sector minorista, visita MongoDB para venta minorista.