Comprehensive comparison for AI technology in applications

import { MongoClient } from 'mongodb';
import { OpenAI } from 'openai';

// MongoDB Atlas Vector Search for Semantic Product Search
const MONGODB_URI = process.env.MONGODB_URI || 'mongodb+srv://user:[email protected]';
const DB_NAME = 'ecommerce';
const COLLECTION_NAME = 'products';
const VECTOR_INDEX_NAME = 'product_vector_index';

const client = new MongoClient(MONGODB_URI);
const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });

interface Product {
  _id?: string;
  name: string;
  description: string;
  category: string;
  price: number;
  embedding?: number[];
}

// Generate embeddings for product descriptions
async function generateEmbedding(text: string): Promise<number[]> {
  try {
    const response = await openai.embeddings.create({
      model: 'text-embedding-3-small',
      input: text,
      dimensions: 1536
    });
    return response.data[0].embedding;
  } catch (error) {
    console.error('Error generating embedding:', error);
    throw new Error('Failed to generate embedding');
  }
}

// Index new products with embeddings
async function indexProduct(product: Product): Promise<string> {
  try {
    await client.connect();
    const db = client.db(DB_NAME);
    const collection = db.collection<Product>(COLLECTION_NAME);

    // Generate embedding from product name and description
    const textToEmbed = `${product.name} ${product.description}`;
    const embedding = await generateEmbedding(textToEmbed);

    const productWithEmbedding = { ...product, embedding };
    const result = await collection.insertOne(productWithEmbedding);

    return result.insertedId.toString();
  } catch (error) {
    console.error('Error indexing product:', error);
    throw error;
  } finally {
    await client.close();
  }
}

// Semantic search using Atlas Vector Search
async function semanticProductSearch(
  query: string,
  limit: number = 10,
  minScore: number = 0.7
): Promise<Product[]> {
  try {
    await client.connect();
    const db = client.db(DB_NAME);
    const collection = db.collection<Product>(COLLECTION_NAME);

    // Generate query embedding
    const queryEmbedding = await generateEmbedding(query);

    // Perform vector search using MongoDB Atlas Search
    const pipeline = [
      {
        $vectorSearch: {
          index: VECTOR_INDEX_NAME,
          path: 'embedding',
          queryVector: queryEmbedding,
          numCandidates: limit * 10,
          limit: limit
        }
      },
      {
        $project: {
          _id: 1,
          name: 1,
          description: 1,
          category: 1,
          price: 1,
          score: { $meta: 'vectorSearchScore' }
        }
      },
      {
        $match: {
          score: { $gte: minScore }
        }
      }
    ];

    const results = await collection.aggregate(pipeline).toArray();
    return results as Product[];
  } catch (error) {
    console.error('Error performing semantic search:', error);
    throw error;
  } finally {
    await client.close();
  }
}

// Example usage
async function main() {
  try {
    // Index a new product
    const newProduct: Product = {
      name: 'Wireless Noise-Canceling Headphones',
      description: 'Premium over-ear headphones with active noise cancellation and 30-hour battery life',
      category: 'Electronics',
      price: 299.99
    };

    const productId = await indexProduct(newProduct);
    console.log(`Product indexed with ID: ${productId}`);

    // Perform semantic search
    const searchResults = await semanticProductSearch(
      'headphones for music with long battery',
      5,
      0.75
    );

    console.log('Search results:', JSON.stringify(searchResults, null, 2));
  } catch (error) {
    console.error('Application error:', error);
    process.exit(1);
  }
}

main();