Leveraging OpenAI and MongoDB Atlas for Improved Search Functionality

1
// This function is the endpoint's request handler. 
2
// It interacts with MongoDB Atlas and OpenAI API for embedding and search functionality.
3
exports = async function({ query }, response) {
4
    // Query params, e.g. '?search=test&beds=2' => {search: "test", beds: "2"}
5
    const { search, beds, rooms, people, maxPrice, freeTextFilter } = query;
6
7
    // MongoDB Atlas configuration.
8
    const mongodb = context.services.get('mongodb-atlas');
9
    const db = mongodb.db('sample_airbnb'); // Replace with your database name.
10
    const listingsAndReviews = db.collection('listingsAndReviews'); // Replace with your collection name.
11
12
    // If there's no search query, return a sample of 30 random documents from the collection.
13
    if (!search || search === "") {
14
      return await listingsAndReviews.aggregate([{$sample: {size: 30}}]).toArray();
15
    }
16
17
    // Fetch the OpenAI key stored in the context values.
18
    const openai_key = context.values.get("openAIKey");
19
20
    // URL to make the request to the OpenAI API.
21
    const url = 'https://api.openai.com/v1/embeddings';
22
23
    // Call OpenAI API to get the embeddings.
24
    let resp = await context.http.post({
25
        url: url,
26
        headers: {
27
            'Authorization': [`Bearer ${openai_key}`],
28
            'Content-Type': ['application/json']
29
        },
30
        body: JSON.stringify({
31
            input: search,
32
            model: "text-embedding-ada-002"
33
        })
34
    });
35
36
    // Parse the JSON response
37
    let responseData = EJSON.parse(resp.body.text());
38
39
    // Check the response status.
40
    if(resp.statusCode === 200) {
41
        console.log("Successfully received embedding.");
42
43
        // Fetch a random sample document.
44
      
45
46
        const embedding = responseData.data[0].embedding;
47
        console.log(JSON.stringify(embedding))
48
49
        let searchQ = {
50
                "index": "default",
51
                "queryVector": embedding,
52
                "path": "doc_embedding",
53
                "k": 100,
54
                "numCandidates": 1000
55
       }
56
57
        // If there's any filter in the query parameters, add it to the search query.
58
        if (freeTextFilter){
59
          // Turn free text search using GPT-4 into filter
60
            const sampleDocs = await listingsAndReviews.aggregate([
61
            { $sample: { size: 1 }},
62
            { $project: {
63
                _id: 0,
64
                bedrooms: 1,
65
                beds: 1,
66
                room_type: 1,
67
                property_type: 1,
68
                price: 1,
69
                accommodates: 1,
70
                bathrooms: 1,
71
                review_scores: 1
72
            }}
73
        ]).toArray();
74
        
75
          const filter =  await context.functions.execute("getSearchAIFilter",sampleDocs[0],freeTextFilter );
76
           searchQ.filter = filter;
77
        }
78
else if(beds || rooms) {
79
  let filter = { "$and" : []} 
80
  
81
   if (beds) {
82
     filter.$and.push({"beds" : {"$gte" : parseInt(beds) }})
83
   }
84
   if (rooms)
85
   {
86
     filter.$and.push({"bedrooms" : {"$gte" : parseInt(rooms) }})
87
   }
88
    searchQ.filter = filter;
89
}
90
91
        // Perform the search with the defined query and limit the result to 50 documents.
92
        let docs = await listingsAndReviews.aggregate([
93
            { "$vectorSearch": searchQ },
94
            { $limit : 50 }
95
        ]).toArray();
96
97
        return docs;
98
    } else {
99
        console.error("Failed to get embeddings");
100
        return [];
101
    }
102
};

1
else if(beds || rooms) {
2
  let filter = { "$and" : []} 
3
  
4
   if (beds) {
5
     filter.$and.push({"beds" : {"$gte" : parseInt(beds) }})
6
   }
7
   if (rooms)
8
   {
9
     filter.$and.push({"bedrooms" : {"$gte" : parseInt(rooms) }})
10
   }
11
    searchQ.filter = filter;
12
}

1
// This function is the endpoint's request handler. 
2
// It interacts with OpenAI API for generating filter JSON based on the input.
3
exports = async function(sampleDoc, search) {
4
    // URL to make the request to the OpenAI API.
5
    const url = 'https://api.openai.com/v1/chat/completions';
6
7
    // Fetch the OpenAI key stored in the context values.
8
    const openai_key = context.values.get("openAIKey");
9
10
    // Convert the sample document to string format.
11
    let syntDocs = JSON.stringify(sampleDoc);
12
    console.log(syntDocs);
13
14
    // Prepare the request string for the OpenAI API.
15
    const reqString = `Convert programmatic command to Atlas $search filter only for range and equals  JS:\n\nExample: Based on document structure {"siblings" : '...', "dob" : "..."} give me the filter of all people  born  2015 and siblings are 3 \nOutput: {"filter":{ "compound" : { "must" : [ {"range": {"gte": 2015, "lte" : 2015,"path": "dob"} },{"equals" : {"value" : 3 , path :"siblings"}}]}}} \n\n  provide the needed filter to accomodate ${search}, pick a path from structure ${syntDocs}. Need just the json object with a range or equal operators. No explanation. No 'Output:' string in response. Valid JSON.`;
16
    console.log(`reqString: ${reqString}`);
17
18
    // Call OpenAI API to get the response.
19
    let resp = await context.http.post({
20
        url: url,
21
        headers: {
22
            'Authorization': `Bearer ${openai_key}`,
23
            'Content-Type': 'application/json'
24
        },
25
        body: JSON.stringify({
26
            model: "gpt-4",
27
            temperature: 0.1,
28
            messages: [
29
                {
30
                    "role": "system",
31
                    "content": "Output  filter json generator follow only provided rules"
32
                },
33
                {
34
                    "role": "user",
35
                    "content": reqString
36
                }
37
            ]
38
        })
39
    });
40
41
    // Parse the JSON response
42
    let responseData = JSON.parse(resp.body.text());
43
44
    // Check the response status.
45
    if(resp.statusCode === 200) {
46
        console.log("Successfully received code.");
47
        console.log(JSON.stringify(responseData));
48
49
        const code = responseData.choices[0].message.content;
50
        let parsedCommand = EJSON.parse(code);
51
        console.log('parsed' + JSON.stringify(parsedCommand));
52
53
        // If the filter exists and it's not an empty object, return it.
54
        if (parsedCommand.filter && Object.keys(parsedCommand.filter).length !== 0) {
55
            return parsedCommand.filter;
56
        }
57
        
58
        // If there's no valid filter, return an empty object.
59
        return {};
60
61
    } else {
62
        console.error("Failed to generate filter JSON.");
63
        console.log(JSON.stringify(responseData));
64
        return {};
65
    }
66
};

1
{$vectorSearch:{
2
    "index": "default",
3
    "queryVector": embedding,
4
    "path": "doc_embedding",
5
    "filter" : { "$and" : [{"beds": {"$gte" : 1}} , "score": {"$gte" : 91}}]},
6
    "k": 100,
7
    "numCandidates": 1000
8
    }
9
}