Advanced Search with Enterprise Server

Solution Overview

Incluso a medida que se acelera la adopción de la nube, muchos clientes optan por una infraestructura autogestionada e implementaciones on-premises, particularly in highly regulated industries. For instance, according to this survey, 93% of government bodies use on-prem deployments, followed by 91% of organizations in the IT industry and 90% in the finance industry. Moreover, many SMEs, such as boutique retailers or regional grocery chains, use on-prem deployments as the high cost to adopt cloud architecture is a financial barrier.

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.

• Operational overwhelm: Teams can struggle to synchronize separate technologies, manage varied resources, and maintain consistent workflows across multiple systems.

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

• Build next generation AI apps on any infrastructure: Reduce architectural complexity, which makes it easier to develop AI-powered solutions and eliminates the need for multiple single-purpose technologies.

• Disfrute de una experiencia coherente en todas partes: Use la misma API de 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.

You don’t need to migrate your existing database. Use MongoDB Enterprise Edition running MongoDB 8.0.10 version or later, either inside or outside a Kubernetes cluster. The Kubernetes operator manages these search nodes and connects them securely to your database cluster, regardless of its deployment location.

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

Both deployment architectures require MongoDB Search and Vector Search nodes deployed within Kubernetes. The following sections describe each approach.

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.

Figure 2. MongoDB Enterprise Server inside of 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

This deployment option configures MongoDB Search and Vector Search nodes inside Kubernetes, which connect to an Enterprise Server replica set deployed outside the Kubernetes cluster. You can use this approach if you have infrastructure requirements or operational preferences outside Kubernetes. The image below illustrates this deployment.

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

Import the sample grocery store inventory data into your MongoDB deployment.

Ejecute el siguiente comando para recuperar la cadena de conexión. Reemplazar <SECRET_NAME> con el nombre de secreto apropiado de Kubernetes generado durante la implementación:

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

This command prints the secret metadata and its encoded contents. Copy the connectionStringStandard value and execute the following command to get the connection string:

echo "<Base64EncodedConnectionString>" | base64 --decode

Run the following command to restore the database from the collections dump folder:

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

Run the following command to confirm that both indexes were created correctly. If successful, the command returns metadata for product_atlas_search and 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
   }
])

The query returns a list of product names and their search score:

[
   {
      _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.

You can deploy the demo locally or on Kubernetes.

Ejecutar localmente

Realice la implementación usando Kubernetes

Run the following code:

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.

Run the backend and frontend inside your Kubernetes cluster using the Docker images built for the demo. Follow these steps:

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. Create the Kubernetes secrets

Store sensitive values in a Kubernetes secret file named retail-secrets.yaml within the retail-unified-commerce/k8s folder. Do not commit real credentials to source control. Below is an example template:

# 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

Apply your Kubernetes deployments:

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

Verify your deployments:

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

Explore the demo’s search capabilities

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.

Figure 4. Search result for green tea face mask

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 chica 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.

• Advanced search capabilities enhance user experience: Full-text search and vector search refine how users explore and access information, driving more intuitive experiences across different industries.

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.