app.py

import gradio as gr
from time import sleep
import json
from pymongo import MongoClient
from bson import ObjectId
from openai import OpenAI
import os
from PIL import Image
import time
import traceback
import asyncio
from langchain_community.vectorstores import MongoDBAtlasVectorSearch
from langchain_openai import OpenAIEmbeddings
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
import base64
import io
from reportlab.pdfgen import canvas
from reportlab.lib.pagesizes import letter
from reportlab.lib.utils import ImageReader
import boto3
import re
import qrcode

output_parser = StrOutputParser()

import json
import requests

openai_client = OpenAI()


def fetch_url_data(url):
    try:
        response = requests.get(url)
        response.raise_for_status()  # Raises an HTTPError if the HTTP request returned an unsuccessful status code
        return response.text
    except requests.RequestException as e:
        return f"Error: {e}"


uri = os.environ.get('MONGODB_ATLAS_URI')
email = "example@example.com"
email_pattern = r"^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$"

# AWS Bedrock client setup
bedrock_runtime = boto3.client('bedrock-runtime',
                               aws_access_key_id=os.environ.get('AWS_ACCESS_KEY'),
                               aws_secret_access_key=os.environ.get('AWS_SECRET_KEY'),
                               region_name="us-east-1")



chatClient = MongoClient(uri)
db_name = 'sample_mflix'
collection_name = 'embedded_movies'
collection = chatClient[db_name][collection_name]


## Chat RAG Functions
try:
    vector_store = MongoDBAtlasVectorSearch(embedding=OpenAIEmbeddings(), collection=collection, index_name='vector_index', text_key='plot', embedding_key='plot_embedding')
    llm = ChatOpenAI(temperature=0)
    prompt = ChatPromptTemplate.from_messages([
    ("system", "You are a movie recommendation engine which post a concise and short summary on relevant movies."),
    ("user", "List of movies: {input}")
     ])
    chain = prompt | llm | output_parser

except:
    #If open ai key is wrong
    print ('Open AI key is wrong')
    vector_store = None
    print("An error occurred: \n" + error_message)

def get_movies(message, history):

    try:
        movies =  vector_store.similarity_search(query=message, k=3, embedding_key='plot_embedding')
        return_text = ''
        for movie in movies:
            return_text = return_text + 'Title : ' +  movie.metadata['title'] + '\n------------\n' + 'Plot: ' + movie.page_content + '\n\n'
    
        print_llm_text = chain.invoke({"input": return_text})
    
        for i in range(len(print_llm_text)):
            time.sleep(0.05)
            yield "Found: " + "\n\n" + print_llm_text[: i+1]
    except Exception as e:
        error_message = traceback.format_exc()
        print("An error occurred: \n" + error_message)
        yield "Please clone the repo and add your open ai key as well as your MongoDB Atlas URI in the Secret Section of you Space\n OPENAI_API_KEY (your Open AI key) and MONGODB_ATLAS_CLUSTER_URI (0.0.0.0/0 whitelisted instance with Vector index created) \n\n For more information : https://mongodb.com/products/platform/atlas-vector-search"
        
    
## Restaurant Advisor RAG Functions
def get_restaurants(search, location, meters):

    try:
        
        client = MongoClient(uri)
        db_name = 'whatscooking'
        collection_name = 'restaurants'
        restaurants_collection = client[db_name][collection_name]
        trips_collection = client[db_name]['smart_trips']

    except:
        print("Error Connecting to the MongoDB Atlas Cluster")
        

    # Pre aggregate restaurants collection based on chosen location and radius, the output is stored into
    # trips_collection
    try:
        newTrip, pre_agg = pre_aggregate_meters(restaurants_collection, location, meters)
        
        ## Get openai embeddings
        response = openai_client.embeddings.create(
                input=search,
                model="text-embedding-3-small",
                dimensions=256
            )

        ## prepare the similarity search on current trip
        vectorQuery = {
            "$vectorSearch": {
                "index" : "vector_index",
                "queryVector": response.data[0].embedding,
                "path" : "embedding",
                "numCandidates": 10,
                "limit": 3,
                "filter": {"searchTrip": newTrip}
            }}

        ## Run the retrieved documents through a RAG system.
        restaurant_docs = list(trips_collection.aggregate([vectorQuery,
            {"$project": {"_id" : 0, "embedding": 0}}]))

        
        chat_response = openai_client.chat.completions.create(
            model="gpt-3.5-turbo",
            messages=[
                {"role": "system", "content": "You are a helpful restaurant assistant. You will get a context if the  context is not relevat to the user query please address that and not provide by default the restaurants as is."},
                { "role": "user", "content": f"Find me the 2 best restaurant and why based on {search} and  {restaurant_docs}. explain trades offs and why I should go to each one. You can mention the third option as a possible alternative."}
            ]
            )

        ## Removed the temporary documents
        trips_collection.delete_many({"searchTrip": newTrip})

        
        if len(restaurant_docs) == 0:
            return "No restaurants found", '<iframe style="background: #FFFFFF;border: none;border-radius: 2px;box-shadow: 0 2px 10px 0 rgba(70, 76, 79, .2);" width="640" height="480" src="https://charts.mongodb.com/charts-paveldev-wiumf/embed/charts?id=65c24b0c-2215-4e6f-829c-f484dfd8a90c&filter={\'restaurant_id\':\'\'}&maxDataAge=3600&theme=light&autoRefresh=true"></iframe>', str(pre_agg), str(vectorQuery)

        ## Build the map filter
        first_restaurant = restaurant_docs[0]['restaurant_id']
        second_restaurant = restaurant_docs[1]['restaurant_id']
        third_restaurant = restaurant_docs[2]['restaurant_id']
        restaurant_string = f"'{first_restaurant}', '{second_restaurant}', '{third_restaurant}'"

    
        iframe = '<iframe style="background: #FFFFFF;border: none;border-radius: 2px;box-shadow: 0 2px 10px 0 rgba(70, 76, 79, .2);" width="640" height="480" src="https://charts.mongodb.com/charts-paveldev-wiumf/embed/charts?id=65c24b0c-2215-4e6f-829c-f484dfd8a90c&filter={\'restaurant_id\':{$in:['  + restaurant_string  + ']}}&maxDataAge=3600&theme=light&autoRefresh=true"></iframe>'
        client.close()
        return chat_response.choices[0].message.content, iframe,str(pre_agg), str(vectorQuery)
    except Exception as e:
        print(e)
        return "Your query caused an error, please retry with allowed input only ...", '<iframe style="background: #FFFFFF;border: none;border-radius: 2px;box-shadow: 0 2px 10px 0 rgba(70, 76, 79, .2);" width="640" height="480" src="https://charts.mongodb.com/charts-paveldev-wiumf/embed/charts?id=65c24b0c-2215-4e6f-829c-f484dfd8a90c&filter={\'restaurant_id\':\'\'}&maxDataAge=3600&theme=light&autoRefresh=true"></iframe>', str(pre_agg), str(vectorQuery)
    

def pre_aggregate_meters(restaurants_collection, location, meters):

    ## Do the geo location preaggregate and assign the search trip id.
    tripId = ObjectId()
    pre_aggregate_pipeline =  [{
            "$geoNear": {
            "near": location,
            "distanceField": "distance",
            "maxDistance": meters,
            "spherical": True,
            },
        },
        {
            "$addFields": {
                "searchTrip" : tripId,
                "date" : tripId.generation_time
            }
        },
        {
            "$merge": {
                "into": "smart_trips"
            }
        } ]

    result = restaurants_collection.aggregate(pre_aggregate_pipeline);

    sleep(3)

    return tripId, pre_aggregate_pipeline

## Celeb Matcher RAG Functions
def construct_bedrock_body(base64_string, text):
    if text:
        return json.dumps({
            "inputImage": base64_string,
            "embeddingConfig": {"outputEmbeddingLength": 1024},
            "inputText": text
        })
    return json.dumps({
        "inputImage": base64_string,
        "embeddingConfig": {"outputEmbeddingLength": 1024},
    })

# Function to get the embedding from Bedrock model
def get_embedding_from_titan_multimodal(body):
    response = bedrock_runtime.invoke_model(
        body=body,
        modelId="amazon.titan-embed-image-v1",
        accept="application/json",
        contentType="application/json",
    )
    response_body = json.loads(response.get("body").read())
    return response_body["embedding"]

# MongoDB setup
uri = os.environ.get('MONGODB_ATLAS_URI')
client = MongoClient(uri)
db_name = 'celebrity_1000_embeddings'
collection_name = 'celeb_images'
celeb_images = client[db_name][collection_name]

participants_db = client[db_name]['participants']

# Function to record participant details
def record_participant(email, company, description, images):
    if not email or not company:
        ## regex to validate email
        if not re.match(email_pattern, email):
            raise gr.Error("Please enter a valid email address")
        
        raise gr.Error("Please enter your email and company name to record the participant details.")
    if not images:
        raise gr.Error("Please search for an image first before recording the participant.")

    participant_data = {'email': email, 'company': company}
    participants_db.insert_one(participant_data)

    # Create PDF after recording participant
    qr_image = create_pdf(images, description, email, company)
    return qr_image

def create_pdf(images, description, email, company):
    print(images)
    
    filename = f"image_search_results_{email}.pdf"
    c = canvas.Canvas(filename, pagesize=letter)
    width, height = letter
    y_position = height

    c.drawString(50, y_position - 30, f"Thanks for participating, {email}! ")
    
    c.drawString(50, y_position - 50, f"Useful resources : ")
    c.drawString(50, y_position - 70, f"Hugging Face: https://huggingface.co/spaces/MongoDB")
    c.drawString(50, y_position - 90, f"DevCenter Content: https://www.mongodb.com/developer/articles/")
    c.drawString(50, y_position - 120, f"Here are your celeb match results:")

    c.drawString(50, y_position - 140, f"Vision summary of the MongoDB  celeb comparison:")

   # Split the description into words
    words = description.split()

    # Initialize variables
    lines = []
    current_line = []

    # Iterate through words and group them into lines
    for word in words:
        current_line.append(word)
        if len(current_line) == 10:  # Split every 10 words
            lines.append(" ".join(current_line))
            current_line = []

    # Add the remaining words to the last line
    if current_line:
        lines.append(" ".join(current_line))

    # Write each line of the description
    y_position -= 170  # Initial Y position
    for line in lines:
        c.drawString(50, y_position, line)
        y_position -= 15  # Adjust for line spacing

    image_position = y_position
    for image in images:
        print(image)
        image_position -= 300  # Adjust this based on your image sizes
        if image_position <= 150:
            c.showPage()
            image_position = height - 50

        buffered = io.BytesIO()

        pil_image = Image.open(image[0])
        pil_image.save(buffered, format='JPEG')
        c.drawImage(ImageReader(buffered), 50, image_position - 150, width=200, height=200)


   
    c.save()


    
    return filename


# Function to generate image description using Claude 3 Sonnet
def generate_image_description_with_claude(images_base64_strs, image_base64):
    claude_body = json.dumps({
        "anthropic_version": "bedrock-2023-05-31",
        "max_tokens": 1000,
        "system": "Please act as face comperison analyzer.",
        "messages": [{
            "role": "user",
            "content": [
                {"type": "image", "source": {"type": "base64", "media_type": "image/jpeg", "data": image_base64}},
                 {"type": "image", "source": {"type": "base64", "media_type": "image/jpeg", "data": images_base64_strs[0]}},
                 {"type": "image", "source": {"type": "base64", "media_type": "image/jpeg", "data": images_base64_strs[1]}},
                 {"type": "image", "source": {"type": "base64", "media_type": "image/jpeg", "data": images_base64_strs[2]}},
                {"type": "text", "text": "Please let the user know how his first image is similar to the other 3 and which one is the most similar?"}
            ]
        }]
    })

    claude_response = bedrock_runtime.invoke_model(
        body=claude_body,
        modelId="anthropic.claude-3-sonnet-20240229-v1:0",
        accept="application/json",
        contentType="application/json",
    )
    response_body = json.loads(claude_response.get("body").read())
    # Assuming the response contains a field 'content' with the description
    return response_body["content"][0].get("text", "No description available")

# Main function to start image search
def start_image_search(image, text):
    if not image:
        raise gr.Error("Please upload an image first, make sure to press the 'Submit' button after selecting the image.")
    buffered = io.BytesIO()
    image = image.resize((800, 600))
    image.save(buffered, format="JPEG", quality=85)
    img_byte = buffered.getvalue()
    img_base64 = base64.b64encode(img_byte)
    img_base64_str = img_base64.decode('utf-8')
    body = construct_bedrock_body(img_base64_str, text)
    embedding = get_embedding_from_titan_multimodal(body)

    doc = list(celeb_images.aggregate([
        {
            "$vectorSearch": {
                "index": "vector_index",
                "path": "embeddings",
                "queryVector": embedding,
                "numCandidates": 15,
                "limit": 3
            }
        }, {"$project": {"image": 1}}
    ]))
    
    images = []
    images_base64_strs = []
    for image_doc in doc:
        pil_image = Image.open(io.BytesIO(base64.b64decode(image_doc['image'])))
        img_byte = io.BytesIO()
        pil_image.save(img_byte, format='JPEG')
        img_base64 = base64.b64encode(img_byte.getvalue()).decode('utf-8')
        images_base64_strs.append(img_base64)
        images.append(pil_image)
    
    description = generate_image_description_with_claude(images_base64_strs, img_base64_str)
    return images, description

def generate_qr_code(filename):

    # Generate QR code
    qr = qrcode.QRCode(
        version=None,
        error_correction=qrcode.constants.ERROR_CORRECT_L,
        box_size=4,
        border=2,
    )
    qr.add_data(filename)
    qr.make(fit=True)

    img_qr = qr.make_image(fill_color="black", back_color="white")

    # Convert PIL Image to bytes for Gradio output
    img_byte_arr = io.BytesIO()
    img_qr.save(img_byte_arr, format='PNG')
    img_byte_arr = img_byte_arr.getvalue()
    image = Image.open(io.BytesIO(img_byte_arr))

    return image

def on_change_make_qr(input):

    qr_code_result = generate_qr_code("https://mongodb-groupeddemo.hf.space/file=" + input)
    return qr_code_result


with gr.Blocks() as demo:

    with gr.Tab("Celeb Matcher Demo"):
        with gr.Tab("Demo"):
            gr.Markdown("""
                # MongoDB's Vector Celeb Image Matcher  

                Upload an image and find the most similar celeb image from the database, along with an AI-generated description.

                💪 Make a great pose to impact the search! 🤯
                """)
            with gr.Row():
                with gr.Column():
                    image_input = gr.Image(type="pil", label="Upload an image")
                    text_input = gr.Textbox(label="Enter an adjustment to the image")
                    search_button = gr.Button("Search")
            
                
                with gr.Column():
                    output_gallery = gr.Gallery(label="Located images", show_label=False, elem_id="gallery",
                                                columns=[3], rows=[1], object_fit="contain", height="auto")
                    output_description = gr.Textbox(label="AI Based vision description")
            gr.Markdown("""

                    """)
            with gr.Row():
                email_input = gr.Textbox(label="Enter your email")
                company_input = gr.Textbox(label="Enter your company name")
                record_button = gr.Button("Record & Download PDF")

            search_button.click(
                fn=start_image_search,
                inputs=[image_input, text_input],
                outputs=[output_gallery, output_description]
            )


            download_file=gr.File(label="Download file")
            record_button.click(
                fn=record_participant,
                inputs=[email_input, company_input, output_description, output_gallery],
                outputs=[download_file]
            )
            download_file.change(on_change_make_qr, inputs=download_file, outputs=gr.Image(type="numpy",width=500, height=500))

        with gr.Tab("Code"):
            gr.Code(label="Code", language="python", value=fetch_url_data('https://huggingface.co/spaces/MongoDB/aws-bedrock-celeb-matcher/raw/main/app.py'))
    
    with gr.Tab("Chat RAG Demo"):
        with gr.Tab("Demo"):
            gr.ChatInterface(get_movies, examples=["What movies are scary?", "Find me a comedy", "Movies for kids"], title="Movies Atlas Vector Search",description="This small chat uses a similarity search to find relevant movies, it uses MongoDB Atlas Vector Search read more here: https://www.mongodb.com/docs/atlas/atlas-vector-search/vector-search-tutorial",submit_btn="Search").queue()
        with gr.Tab("Code"):
            gr.Code(label="Code", language="python", value=fetch_url_data('https://huggingface.co/spaces/MongoDB/MongoDB-Movie-Search/raw/main/app.py'))

    with gr.Tab("Restaruant advisor RAG Demo"):
        with gr.Tab("Demo"):
            gr.Markdown(
            """
            # MongoDB's Vector Restaurant planner 
            Start typing below to see the results. You can search a specific cuisine for you and choose 3 predefined locations.
            The radius specify the distance from the start search location. This space uses the dataset called [whatscooking.restaurants](https://huggingface.co/datasets/AIatMongoDB/whatscooking.restaurants)
            """)

            # Create the interface
            gr.Interface(
                get_restaurants,
                [gr.Textbox(placeholder="What type of dinner are you looking for?"),
                gr.Radio(choices=[
                        ("Timesquare Manhattan", {
                            "type": "Point",
                            "coordinates": [-73.98527039999999, 40.7589099]
                        }),
                        ("Westside Manhattan", {
                            "type": "Point",
                            "coordinates": [-74.013686, 40.701975]
                        }),
                        ("Downtown Manhattan", {
                            "type": "Point",
                            "coordinates": [-74.000468, 40.720777]
                        })
                    ], label="Location", info="What location you need?"),
                gr.Slider(minimum=500, maximum=10000, randomize=False, step=5, label="Radius in meters")],
            [gr.Textbox(label="MongoDB Vector Recommendations", placeholder="Results will be displayed here"), "html",
                gr.Code(label="Pre-aggregate pipeline",language="json" ),
                gr.Code(label="Vector Query", language="json")]
            )
        with gr.Tab("Code"):
             gr.Code(label="Code", language="python", value=fetch_url_data('https://huggingface.co/spaces/MongoDB/whatscooking-advisor/raw/main/app.py'))


   
if __name__ == "__main__":
    demo.launch()