Add more functions and improve front

.gitignore

@@ -1,4 +1,7 @@
 .idea/
 .venv/
 __pycache__/
-.env
+.env
+
+assets/
+tts_model/

app.py

@@ -1,14 +1,18 @@
 from dotenv import load_dotenv
 load_dotenv()
 
-from utils import *
+import utils
+import chatbot
 import gradio as gr
 
 
 with gr.Blocks() as app:
+    # ----------------------------------------------- FRONT -------------------------------------------------------
     with gr.Tab('General info'):
-        client = gr.Textbox(label='Nombre del cliente', placeholder='Inserte el nombre del cliente')
-        language = gr.Checkboxgroup(
+        client = gr.Textbox(
+            label='Nombre del cliente', placeholder='Inserte el nombre del cliente, por ejemplo Visit Orlando'
+        )
+        languages = gr.Checkboxgroup(
             choices=['español', 'ingles', 'portugués'], value='español', label='Idiomas', interactive=True,
             info='Seleccione todos los idiomas que el chatbot va a hablar (al menos debe tener 1 idioma)'
         )
@@ -16,7 +20,7 @@ with gr.Blocks() as app:
             choices=['Bella'], value='Bella', label='Nombre del chatbot',
             info='Seleccione el nombre del chatbot, si no se encuentra en la lista, contacte al administrador'
         )
-        num_questions = gr.Number(
+        max_num_questions = gr.Number(
             value=5, minimum=2, maximum=10, label='Número preguntas', interactive=True,
             info='Máximo numero de preguntas que puede hacer el usuario.'
         )
@@ -32,11 +36,15 @@ with gr.Blocks() as app:
             greet = gr.Textbox(label='Mensaje', info='Ingrese el mensaje a decir por el chatbot.')
             type_greet = gr.Dropdown(
                 choices=['Saludo', 'Despedida', 'Error'], value='Saludo', interactive=True,
-                info='Seleccione si es saludo, despedida o mensaje de error.'
+                info='Seleccione si es saludo, despedida o mensaje de error.', label='Tipo mensaje'
+            )
+            language_greet = gr.Dropdown(
+                choices=['español'], value= 'español', interactive=True,
+                info='Seleccione el idioma en el que esta el texto.', label='Idioma'
             )
             send_greet_button = gr.Button(value='Añadir')
         messages_table = gr.DataFrame(
-            headers=['Eliminar', 'Tipo mensaje', 'Mensaje'], type='array', interactive=False
+            headers=['Eliminar', 'Mensaje', 'Tipo mensaje', 'Idioma'], type='array', interactive=False
         )
 
     with gr.Tab('Random data'):
@@ -44,9 +52,16 @@ with gr.Blocks() as app:
             'Si quiere que Bella diga algunos datos random mientras busca la información, ingrese dichos párrafos aca.'
         )
         with gr.Row():
-            random_data = gr.Text(placeholder='Ingrese el dato random', label='Dato random')
+            random_data = gr.Text(
+                placeholder='Ingrese el dato random', info='Ingrese el mensaje a decir por el chatbot.',
+                label='Dato random'
+            )
+            language_random = gr.Dropdown(
+                choices=['español'], value='español', interactive=True,
+                info='Seleccione el idioma en el que esta el texto.', label='Idioma'
+            )
             send_random_button = gr.Button(value='Añadir')
-        random_table = gr.DataFrame(headers=['Eliminar', 'Dato random'], type='array', interactive=False)
+        random_table = gr.DataFrame(headers=['Eliminar', 'Dato random', 'Idioma'], type='array', interactive=False)
 
     with gr.Tab('Questions - Context'):
         with gr.Row():
@@ -57,31 +72,26 @@ with gr.Blocks() as app:
             headers=['Eliminar', 'Pregunta', 'Contexto'], type='array', interactive=False
         )
 
-    with gr.Tab('General prompt'):
-        general_prompt = gr.Text(placeholder='Ingrese el prompt general del bot', label='Prompt')
-
-    with gr.Tab('Context prompt'):
-        context_prompt = gr.Text(placeholder='Ingrese el prompt usado para encontrar el contexto', label='Prompt')
-
     with gr.Tab('Create chatbot'):
         _ = gr.Markdown(
             "Asegúrese que toda la información este correcta antes de enviarla."
         )
         create_chatbot_button = gr.Button(value='Crear chatbot')
 
+    with gr.Tab('Prompts'):
+        general_prompt = gr.Text(
+            placeholder='Ingrese el prompt general del bot', label='General prompt'
+        )
+        context_prompt = gr.Text(
+            placeholder='Ingrese el prompt usado para encontrar el contexto', label='Standalone prompt'
+        )
+
     with gr.Tab('Test'):
-        with gr.Row():
-            with gr.Column():
-                with gr.Row():
-                    video = gr.Video(interactive=False, label='Video', autoplay=True)
-                with gr.Row():
-                    output_audio = gr.Audio(interactive=False, label='Audio', autoplay=True)
-
-            with gr.Column():
-                with gr.Row():
-                    chat = gr.Chatbot(label='Chat')
-                with gr.Row():
-                    text = gr.Text(label='Write your question')
+        start_test_button = gr.Button(value='Iniciar test')
+        with gr.Row(visible=False) as chat_row:
+            chat = gr.Chatbot(label='Chat')
+            output_audio = gr.Audio(interactive=False, label='Audio', autoplay=True, visible=False)
+            user_input = gr.Text(label='Write your question')
 
     with gr.Tab('Submit'):
         _ = gr.Markdown(
@@ -94,35 +104,63 @@ with gr.Blocks() as app:
 
     # Add info to the tables
     send_greet_button.click(
-        add_data_table, [messages_table, type_greet, greet], [messages_table, greet]
+        utils.add_data_table,
+        [messages_table, greet, type_greet, language_greet],
+        [messages_table, greet, type_greet, language_greet]
     )
     send_random_button.click(
-        add_data_table, [random_table, random_data], [random_table, random_data]
+        utils.add_data_table, [random_table, random_data, language_random], [random_table, random_data, language_random]
     )
     send_question_button.click(
-        add_data_table, [questions_table, question, context], [questions_table, question, context]
+        utils.add_data_table, [questions_table, question, context], [questions_table, question, context]
     )
 
     # Remove info from the tables
     messages_table.select(
-        remove_data_table, messages_table, messages_table
+        utils.remove_data_table, messages_table, messages_table
     )
     random_table.select(
-        remove_data_table, random_table, random_table
+        utils.remove_data_table, random_table, random_table
     )
     questions_table.select(
-        remove_data_table, questions_table, questions_table
+        utils.remove_data_table, questions_table, questions_table
     )
 
-    # Create the chatbot: create media and vectorstore
+    # Create the chatbot: create media (csv files, audio and video) and vectorstore
     create_chatbot_button.click(
-        lambda: gr.Button(value='Creating chatbot...', interactive=False),
+        lambda: gr.update(value='Creating chatbot...', interactive=False),
         None,
         create_chatbot_button
     ).then(
-        create_chatbot,
-        [client, language, name, base_image, messages_table, random_table, questions_table],
+        utils.create_chatbot,
+        [client, name, messages_table, random_table, questions_table],
         create_chatbot_button
     )
 
+    # Update the dataframes based on the languages selected in the first tab
+    languages.change(
+        utils.add_language, languages, [language_greet, language_random]
+    )
+
+    # Initialize chat
+    start_test_button.click(
+        lambda: gr.update(value='Iniciando chat...'), None, start_test_button
+    ).then(
+        chatbot.start_chat, [chat, general_prompt], [chat, output_audio, chat_row]
+    ).then(
+        lambda: gr.update(value='Reiniciar chat'), None, start_test_button
+    )
+
+    # Chat with the chatbot
+    user_input.submit(
+        chatbot.get_random_data, None, output_audio
+    ).then(
+        chatbot.get_answer,
+        [chat, user_input, client, general_prompt, context_prompt],
+        [chat, user_input, output_audio], show_progress='hidden'
+    )
+
+    # Submit chatbot: save prompts and no more ?
+
+
 app.launch(debug=True)

audio.py

@@ -6,37 +6,12 @@ import pickle
 import torchaudio
 import numpy as np
 import gradio as gr
-from google.cloud import storage
+from typing import Optional
 from TTS.tts.models.xtts import Xtts
 from nltk.tokenize import sent_tokenize
-from huggingface_hub import hf_hub_download
 from TTS.tts.configs.xtts_config import XttsConfig
 
 
-def _download_starting_files() -> None:
-    """
-    Downloads the embeddings from a bucket
-    """
-    os.makedirs('assets', exist_ok=True)
-
-    # Download credentials file
-    hf_hub_download(
-        repo_id=os.environ.get('DATA'), repo_type='dataset', filename="credentials.json",
-        token=os.environ.get('HUB_TOKEN'), local_dir="assets"
-    )
-
-    # Initialise a client
-    credentials = os.getenv('GOOGLE_APPLICATION_CREDENTIALS')
-    storage_client = storage.Client.from_service_account_json(credentials)
-    bucket = storage_client.get_bucket('embeddings-bella')
-
-    # Get both embeddings
-    blob = bucket.blob("gpt_cond_latent.npy")
-    blob.download_to_filename('assets/gpt_cond_latent.npy')
-    blob = bucket.blob("speaker_embedding.npy")
-    blob.download_to_filename('assets/speaker_embedding.npy')
-
-
 def _load_array(filename):
     """
     Opens a file a returns it, used with numpy files
@@ -45,12 +20,10 @@ def _load_array(filename):
         return pickle.load(f)
 
 
-# Get embeddings
-_download_starting_files()
 os.environ['COQUI_TOS_AGREED'] = '1'
 
 # Used to generate audio based on a sample
-nltk.download('punkt')
+# nltk.download('punkt')
 model_path = os.path.join("tts_model")
 
 config = XttsConfig()
@@ -62,7 +35,7 @@ model.load_checkpoint(
     checkpoint_path=os.path.join(model_path, "model.pth"),
     vocab_path=os.path.join(model_path, "vocab.json"),
     eval=True,
-    use_deepspeed=True,
+    # use_deepspeed=True,
 )
 
 device = 'cuda' if torch.cuda.is_available() else 'cpu'
@@ -70,31 +43,27 @@ model.to(device)
 
 # Speaker latent
 path_latents = 'assets/gpt_cond_latent.npy'
-gpt_cond_latent = _load_array(path_latents)
+# gpt_cond_latent = _load_array(path_latents)
 
 # Speaker embedding
 path_embedding = 'assets/speaker_embedding.npy'
-speaker_embedding = _load_array(path_embedding)
+# speaker_embedding = _load_array(path_embedding)
 
 
-def get_audio(text: str, language: str = 'es') -> gr.Audio:
+def get_audio(text: str, language: str = 'es', saving_path: str = 'output') -> None:
     """
-    Returns a link from a bucket in GCP that contains the generated audio given a text and language and the
-    name of such audio
-    :param text: used to generate the audio
-    :param language: 'es', 'en' or 'pt'
-    :return link_audio and name_audio
+    Creates an audio with the given text and language, the name of the audio file is output.wav
     """
     # Creates an audio with the answer and saves it as output.wav
-    _save_audio(text, language)
+    _save_audio(text, language, saving_path)
 
-    return gr.Audio(value='output.wav', interactive=False, visible=True)
+    return None
 
 
-def _save_audio(answer: str, language: str) -> None:
+def _save_audio(answer: str, language: str, path_audio: str) -> None:
     """
     Splits the answer into sentences, clean and creates an audio for each one, then concatenates
-    all the audios and saves them into a file (output.wav)
+    all the audios and saves them into a file
     """
     # Split the answer into sentences and clean it
     sentences = _get_clean_answer(answer, language)
@@ -108,19 +77,25 @@ def _save_audio(answer: str, language: str) -> None:
 
     # Concatenate and save all audio segments
     concatenated_audio = torch.cat(audio_segments, dim=0)
-    torchaudio.save('output.wav', concatenated_audio.unsqueeze(0), 24000)
+    torchaudio.save(f'{path_audio}.wav', concatenated_audio.unsqueeze(0), 24000)
 
 
 def _get_voice(sentence: str, language: str) -> np.ndarray:
     """
     Returns a numpy array with a wav of an audio with the given sentence and language
     """
-    out = model.inference(
+    '''out = model.inference(
         sentence,
         language=language,
         gpt_cond_latent=gpt_cond_latent,
         speaker_embedding=speaker_embedding,
         temperature=0.1
+    )'''
+    out = model.synthesize(
+        sentence,
+        config,
+        speaker_wav='assets/orlando2_cleaned.wav',
+        language=language
     )
     return out['wav']
 

audio_model.py

@@ -1,6 +1,24 @@
 import os
 import requests
 from tqdm import tqdm
+from google.cloud import storage
+from huggingface_hub import hf_hub_download
+
+
+def _download_starting_files() -> None:
+    """
+    Downloads the embeddings from a bucket
+    """
+    # Initialise a client
+    credentials = os.getenv('GOOGLE_APPLICATION_CREDENTIALS')
+    storage_client = storage.Client.from_service_account_json(credentials)
+    bucket = storage_client.get_bucket('embeddings-bella')
+
+    # Get both embeddings
+    blob = bucket.blob("gpt_cond_latent.npy")
+    blob.download_to_filename('assets/gpt_cond_latent.npy')
+    blob = bucket.blob("speaker_embedding.npy")
+    blob.download_to_filename('assets/speaker_embedding.npy')
 
 
 def _download_file(url, destination):
@@ -37,3 +55,6 @@ def download_model():
         destination = f'tts_model/{filename}'
         print(f"[COQUI TTS] STARTUP: Downloading {filename}...")
         _download_file(url, destination)
+
+    # Downloads the embeddings from GCP
+    # _download_starting_files()

chatbot.py

@@ -0,0 +1,123 @@
+import os
+import audio
+import random
+import pinecone
+import gradio as gr
+from openai import OpenAI
+
+
+OPENAI_CLIENT = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
+pinecone.init(api_key=os.getenv("PINECONE_API_TOKEN"), environment=os.getenv("PINECONE_ENVIRONMENT"))
+
+
+def start_chat(chat_history: list[list[str | None]]):
+    # Get greeting text and audio
+    greeting = ''
+    audio_name = ''
+
+    chat_history.append(['', greeting])
+
+    return chat_history, gr.update(value=f'{audio_name}.wav'), gr.update(visible=False)
+
+
+def get_random_data(client_name: str):
+    random_options = []
+    path_audios = f'assets/{client_name}/media/audio'
+    for random_audio in os.listdir(path_audios):
+        if random_audio.startswith('random') and 'es' in random_audio:
+            random_options.append(random_audio)
+
+    num = random.randint(0, len(random_options) - 1)
+    return gr.update(value=random_options[num])
+
+
+def get_answer(
+        chat_history: list[tuple[str, str]], user_input: str, client_name: str, general_prompt: str,context_prompt: str
+):
+    # Format chat history to OpenAI format msg history
+    msg_history = [{'role': 'system', 'content': general_prompt}]
+    for i, msg in enumerate(chat_history):
+        if i == 0:
+            continue  # Omit the prompt
+        if i % 2 == 0:
+            msg_history.append({'role': 'user', 'content': msg})
+        else:
+            msg_history.append({'role': 'assistant', 'content': msg})
+
+    # Get standalone question
+    standalone_question = _get_standalone_question(user_input, msg_history, context_prompt)
+
+    # Get context
+    context = _get_context(standalone_question, client_name)
+
+    # Get answer from chatbot
+    response = _get_response(context, msg_history, user_input, general_prompt)
+
+    # Get audio
+    audio.get_audio(response, 'es')
+
+    # Update chat_history
+    chat_history.append((user_input, response))
+
+    return chat_history, "", gr.update(value='output.wav')
+
+
+def _get_response(context: str, message_history: list[dict], question: str, prompt: str) -> str:
+    message_history[0]['content'] = prompt.replace('CONTEXT', context)
+    message_history.append({'role': 'user', 'content': question})
+    return _call_api(message_history)
+
+
+def _get_embedding(text: str) -> list[float]:
+    response = OPENAI_CLIENT.embeddings.create(
+        input=text,
+        model='text-embedding-ada-002'
+    )
+    return response.data[0].embedding
+
+
+def _call_api(message_history: list[dict]) -> str:
+    response = OPENAI_CLIENT.chat.completions.create(
+        model='gpt-4-turbo-preview',
+        temperature=0.7,
+        messages=message_history
+    )
+    return response.choices[0].message.content
+
+
+def _get_standalone_question(question: str, message_history: list[dict], prompt_q: str) -> str:
+    # Format the message history like: Human: blablablá \nAssistant: blablablá
+    history = ''
+    for i, msg in enumerate(message_history):
+        if i == 0:
+            continue  # Omit the prompt
+        if i % 2 == 0:
+            history += f'Human: {msg["content"]}\n'
+        else:
+            history += f'Assistant: {msg["content"]}\n'
+
+    # Add history and question to the prompt and call chatgpt
+    prompt = [{'role': 'system', 'content': ''}]
+    content = prompt_q.replace('HISTORY', history).replace('QUESTION', question)
+    prompt[0]['content'] = content
+
+    return _call_api(prompt)
+
+
+def _get_context(question: str, client_name: str) -> str:
+    q_embedding = _get_embedding(question)
+
+    # Get most similar vectors
+    index = pinecone.Index(client_name)
+    result = index.query(
+        vector=q_embedding,
+        top_k=10,
+        include_metadata=True,
+        namespace=f'{client_name}-context'
+    )['matches']
+
+    # Crete a string based on the text of each vector
+    context = ''
+    for r in result:
+        context += r['metadata']['Text'] + '\n'
+    return context

gcp.py

@@ -0,0 +1,47 @@
+import os
+from pathlib import Path
+from datetime import timedelta
+from google.cloud import storage
+from huggingface_hub import hf_hub_download
+from google.cloud.storage import transfer_manager
+
+
+def download_credentials():
+    os.makedirs('assets', exist_ok=True)
+
+    # Download credentials file
+    hf_hub_download(
+        repo_id=os.environ.get('DATA'), repo_type='dataset', filename="credentials.json",
+        token=os.environ.get('HUB_TOKEN'), local_dir="assets"
+    )
+
+
+def upload_folder(bucket_name: str, source_directory: str) -> None:
+    # Filter so the list only includes files, not directories themselves.
+    string_paths = [
+        str(path.relative_to(source_directory)) for path in Path(source_directory).rglob("*") if path.is_file()
+    ]
+
+    # Start the upload.
+    bucket = STORAGE_CLIENT.bucket(bucket_name)
+    results = transfer_manager.upload_many_from_filenames(
+        bucket, string_paths, source_directory=source_directory, max_workers=2
+    )
+
+    for name, result in zip(string_paths, results):
+        if isinstance(result, Exception):
+            print(f"Failed to upload {name} due to exception: {result}")
+        else:
+            print(f"Uploaded {name} to {bucket.name}.")
+
+
+def get_link_file(bucket_name: str, client_name: str, type_media: str, media_name: str):
+    bucket = STORAGE_CLIENT.bucket(bucket_name)
+    blobs = bucket.list_blobs(prefix=f'{client_name}/media/{type_media}/{media_name}')
+    blob = next(blobs)
+    signed_url = blob.generate_signed_url(expiration=timedelta(minutes=15))
+    return signed_url
+
+
+download_credentials()
+STORAGE_CLIENT = storage.Client.from_service_account_json(os.getenv('GOOGLE_APPLICATION_CREDENTIALS'))

requirements.txt

@@ -9,4 +9,6 @@ torch==2.1.1
 torchaudio==2.1.1
 TTS==0.21.2
 google-cloud-storage==2.13.0
-numpy==1.22.0
+numpy==1.22.0
+openai==1.10.0
+clint==0.5.1

utils.py

@@ -1,36 +1,44 @@
-import os
-import gradio as gr
+import csv
+import uuid
+import pinecone
+from typing import Union
+from openai import Client
+from pinecone import Index
+
+from gcp import *
 import audio_model
 if not os.path.exists('tts_model'):  # Get TTS model
     audio_model.download_model()
-import audio
+    pass
+from audio import *
+from video import *
 
 
-def add_data_table(table: list[list[str]], first: str, last: str = None):
+pinecone.init(api_key=os.getenv('PINECONE_API_KEY'), environment=os.getenv('PINECONE_ENV'))
+INDEX = Index(os.getenv('PINECONE_INDEX'))
+OPENAI_CLIENT = Client()
+
+
+def add_data_table(table: list[list[str]], *data: str):
     """
     Adds the data to the table. Some data consist of two columns others only one.
     So depending on that, the new row and returned value will be different-
     """
-    if last is None:
-        new_row = ['❌', first]
-        new_value = ''
-    elif first == 'Saludo' or first == 'Despedida' or first == 'Error':
-        new_row = ['❌', first, last]
-        new_value = '', first
+    if len(data) == 3:  # It is the greet tab
+        new_value = '', *data[1:]
+    elif data[-1] in ['español', 'ingles', 'portugués']:
+        new_value = '', data[-1]
     else:
-        new_row = ['❌', first, last]
         new_value = '', ''
 
     # The table is empty, do not append it but replace the first row
     if all(column == '' for column in table[0]):
-        table[0] = new_row
+        table[0] = ['❌', *data]
 
     # Add the new data
     else:
-        table.append(new_row)
+        table.append(['❌', *data])
 
-    if last is None:
-        return table, new_value
     return table, *new_value
 
 
@@ -52,22 +60,96 @@ def remove_data_table(table: list[list[str]], evt: gr.SelectData):
     return table
 
 
+def add_language(languages: list[str]) -> Union[gr.Error, tuple[gr.helpers, gr.helpers]]:
+    if len(languages) == 0:
+        raise gr.Error('Debe seleccionar al menos 1 idioma')
+
+    return (
+        gr.update(choices=[i for i in languages], value=languages[0], interactive=True),
+        gr.update(choices=[i for i in languages], value=languages[0], interactive=True)
+    )
+
+
 def create_chatbot(
-        client: str, language: list[str], chatbot: str, messages_table, random_table, questions_table,
+        client: str, name: str, messages_table: list[str, ], random_table, questions_table,
 ):
+    translate_language = {'español': 'es', 'ingles': 'en', 'portugués': 'pt'}
+    translate_greet = {'Saludo': 'greeting', 'Despedida': 'goodbye', 'Error': 'error'}
+
     # Set up general info
     client_name = client.lower().replace(' ', '-')
-    chatbot_name = chatbot.lower()
+    chatbot_name = name.lower()
 
-    # Create prerecorded media (greeting, goodbye, error, random and waiting)
+    # Group messages by their type (greeting, goodbye or error) and language
+    messages = dict()
     for message in messages_table:
-        pass
-
-    # get_audio()
+        type_msg = translate_greet[message[1]]
+        language_msg = translate_language[message[-1]]
+        os.makedirs(f'assets/{client_name}/{type_msg}s', exist_ok=True)
+        if type_msg not in messages:
+            messages[type_msg] = {language_msg: [message[2]]}
+        else:
+            if language_msg not in messages[type_msg]:
+                messages[type_msg][language_msg] = [message[2]]
+            else:
+                messages[type_msg][language_msg].append(message[2])
+
+    # Create CSV files (greeting, goodbye and error)
+    for type_msg in messages:
+        for language in messages[type_msg]:
+            with open(f'assets/{client_name}/{type_msg}/{language}.csv', mode='w', encoding='utf-8') as outfile:
+                writer = csv.writer(outfile, delimiter=',')
+                writer.writerows(messages[type_msg][language])
+
+    # Create the audios (greeting, goodbye and error)
+    os.makedirs(f'assets/{client_name}/media/audio', exist_ok=True)
+    for type_msg in messages:
+        for language in messages[type_msg]:
+            for i, msg in enumerate(messages[type_msg][language]):
+                full_path = f'assets/{client_name}/media/audio/{type_msg}_{language}_{i}.wav'
+                # get_audio(msg, language, full_path)
+
+    # Create the random audios
+    for i, (_, msg, language) in enumerate(random_table):
+        full_path = f'assets/{client_name}/media/audio/random_{language}_{i}.wav'
+        # get_audio(msg, language, full_path)
+
+    # Upload files and audios to bucket in GCP
+    upload_folder('clients-bella', f'assets/{client_name}')
+
+    # Create videos
+    os.makedirs(f'assets/{client_name}/media/video', exist_ok=True)
+    for audio_file in os.listdir(f'assets/{client_name}/media/audio'):
+        name_file = audio_file.split('.')[0]
+        link_audio = get_link_file('clients-bella', client_name, 'audio', audio_file)
+        get_video(link_audio, f'assets/{client_name}/media/audio/{name_file}.mp4')
+
+    # Upload videos to GCP
+    upload_folder('clients-bella', f'assets/{client_name}/media/video')
 
     # Set up vectorstore
-
-    # Upload data to bucket in CP (videos, audio, prompts and csv files)
+    vectors = []
+    for _, question, context in questions_table:
+        vector = {
+            "id": str(uuid.uuid4()),
+            "values": _get_embedding(question),
+            "metadata": {'Text': context},
+        }
+        vectors.append(vector)
+    INDEX.upsert(vectors=vectors, namespace=f'{client_name}-context')
 
     # Change text in the button
     return gr.Button(value='Chatbot created!!!', interactive=True)
+
+
+def _get_embedding(sentence: str) -> list[float]:
+    """
+    Returns the embedding of a sentence
+    :param sentence: input of the model
+    :return: list of floats representing the embedding
+    """
+    response = OPENAI_CLIENT.embeddings.create(
+        input=sentence,
+        model='text-embedding-ada-002'
+    )
+    return response.data[0].embedding

video.py

@@ -0,0 +1,94 @@
+import os
+import time
+import requests
+import logging
+from clint.textui import progress
+
+
+def get_video(link_audio: str, path_video: str) -> bool:
+    """
+    Saves a video created with d-id into a file (video.mp4). It returns True if there was not a
+    problem during the process, False otherwise
+    """
+    status, id_video = _create_talk(link_audio)
+
+    # There was a problem with D-ID
+    if not status:
+        return False
+
+    link_video = _get_url_talk(id_video)
+
+    # Saves the video into a file to later upload it to the cloud
+    name = f'{path_video}.mp4'
+    r = requests.get(link_video + name, stream=True)
+    with open(name, 'wb') as f:
+        total_length = int(r.headers.get('content-length'))
+        for chunk in progress.bar(r.iter_content(chunk_size=1024), expected_size=(total_length / 1024) + 1):
+            if chunk:
+                f.write(chunk)
+                f.flush()
+    return True
+
+
+def _create_talk(link_audio: str) -> tuple[bool, str]:
+    """
+    Creates and returns the id of the talk made with d-id. It receives the status of the call and
+    the link of an audio that is in a bucket and contains the answer of the bot
+    """
+    url = "https://api.d-id.com/talks"
+
+    payload = {
+        "script": {
+            "type": "audio",
+            "provider": {
+                "type": "microsoft",
+                "voice_id": "en-US-JennyNeural"
+            },
+            "ssml": "false",
+            "audio_url": link_audio
+        },
+        "config": {
+            "fluent": "false",
+            "pad_audio": "0.0",
+            "stitch": True
+        },
+        "source_url": os.getenv('D_ID_IMAGE')
+    }
+    headers = {
+        "accept": "application/json",
+        "content-type": "application/json",
+        "authorization": f"Basic {os.getenv('D_ID_KEY')}"
+    }
+
+    response = requests.post(url, json=payload, headers=headers)
+    r = response.json()
+
+    try:
+        talk_id = r['id']
+        return True, talk_id
+
+    # Probably there are no more available credits
+    except KeyError:
+        logging.error(f"D-ID response is missing 'id' key. Returned error: {r}")
+        return False, 'None'
+
+
+def _get_url_talk(id_video: str) -> str:
+    """
+    Returns the url of the video given the id of a talk
+    """
+    url = f"https://api.d-id.com/talks/{id_video}"
+
+    while True:
+        headers = {
+            "accept": "application/json",
+            "authorization": f"Basic {os.getenv('D_ID_KEY')}"
+        }
+        response = requests.get(url, headers=headers)
+        r = response.json()
+
+        if r['status'] == 'done':
+            break
+        time.sleep(1)  # Sleep until the video is ready
+
+    return r['result_url']