Add application file

app.py

@@ -0,0 +1,202 @@
+import gradio as gr
+import time
+from arxiv_agent import *
+agent = ArxivAgent()
+
+def set_profile(name):
+    # Simulate setting the profile based on the name
+    # Replace with actual logic to fetch and set profile
+    names = name.split(" ")
+    for n in names:
+        if len(n) == 0: 
+            gr.Info("Please input standard name format.")
+            return None
+        elif n[0].islower(): 
+            gr.Info("Please input standard name format.")
+            return None
+    profile = agent.get_profile(name)
+    # import pdb
+    # pdb.set_trace()
+
+    return profile
+
+
+def edit_profile(profile, author_name):
+    # names = author_name.split(" ")
+    # for n in names:
+    #     if len(n) == 0: 
+    #         gr.Info("Please input standard name format.")
+    #         return "", False
+    #     elif n[0].islower(): 
+    #         gr.Info("Please input standard name format.")
+    #         return "", False
+
+    msg = agent.edit_profile(profile, author_name)
+    gr.Info("Edit profile successfully!")
+    return profile
+
+def confirm_date(date, profile_input):
+    # Simulate fetching data based on the selected date
+    # data = request.get_json()
+    if len(profile_input) == 0:
+        topic, papers, idea = agent.select_date(date, None)
+    else:
+        topic, papers, idea = agent.select_date(date, profile_input)
+    return topic[0], papers, idea[0]
+
+def send_text(query, profile_input):
+    # Simulate sending a query and receiving a response
+    if len(profile_input) <= 1:
+        Ans1, Ans2 = agent.response(query, None)
+    else:
+        Ans1, Ans2 = agent.response(query, profile_input)
+
+    return Ans1[0], Ans2[0]
+
+
+
+def send_comment(comment):
+    # Simulate sending a comment
+    message = agent.update_comment(comment)
+    gr.Info("Thank you for your comment!")
+
+    return message[0]
+
+
+
+def respond(message, chat_history, profile):
+    
+    bot_message1, bot_message2 = send_text(message, profile)
+
+
+    # bot_message1, bot_message2 = "a", "b"
+    chat_history.append((message, None))
+    chat_history.append((bot_message1, bot_message2))
+
+    time.sleep(2)
+
+    return "", chat_history
+
+  
+
+with gr.Blocks(css="""#chat_container {height: 820px; width: 1000px; margin-left: auto; margin-right: auto;}
+            #chatbot {height: 600px; overflow: auto;}
+            #create_container {height: 750px; margin-left: 0px; margin-right: 0px;}
+            #tokenizer_renderer span {white-space: pre-wrap}
+            """,
+    theme="bethecloud/storj_theme",title="Arxiv Copilot") as app:
+    with gr.Row():
+        with gr.Column(scale=2):
+            gr.Image(
+                "images/arxiv_copilot.PNG", elem_id="banner-image", show_label=False
+            )
+        with gr.Column(scale=5):
+            gr.Markdown(
+                """# Arxiv Copilot
+                ➡️️ **Goals**: Arxiv Copilot aims to provide personalized academic service! 
+                
+                ✨ **Guidance**: 
+                
+                Step (1) Enter researcher name and generate research profile in "Set your profile!"🧑‍💼
+                
+                Step (2) Select time range and get relevant topic trend and ideas in "Get research trend and ideas!"💡
+
+                Step (3) Chat with Arxiv Copilot and choose the better response from two answers in "Chat with Arxiv Copilot!"; Here we appreciate any further feedback 🎉
+                
+                ⚠️ **Limitations**: We mainly provide research service related to machine learning field now, other fields will be added in the future.
+
+                🗄️ **Disclaimer**: User behavior data will be collected for the pure research purpose. If you use this demo, you may implicitly agree to these terms.
+                """
+            )
+
+
+    # gr.Markdown("Provide research service using this demo.")
+    with gr.Accordion("Set your profile!", open=True):
+        gr.Markdown(
+            """
+            You can input your name in standard format to get your profile from arxiv here. Standard examples: Yoshua Bengio. Wrong examples: yoshua bengio, Yoshua bengio, yoshua Bengio.
+            """
+        )
+        with gr.Row():
+            with gr.Column(scale=2, min_width=300):
+                name_input = gr.Textbox(label="Input Your Name")
+                set_button = gr.Button("Set Profile")
+            profile_text = gr.Textbox(label="Generated Profile", interactive=True, scale=7, lines=5, max_lines=5)
+            edit_button = gr.Button("Edit Profile", scale=1)
+        set_button.click(set_profile, inputs=name_input, outputs=[profile_text])
+        edit_button.click(edit_profile, inputs=[profile_text, name_input], outputs=[profile_text])
+
+    with gr.Accordion("Get research trend and ideas!", open=True):
+        gr.Markdown(
+            """
+            We will give you personalized research trend and ideas if you have set your profile. Otherwise, general research trend will be provided.
+            """
+        )
+        with gr.Column():
+            with gr.Row():
+                with gr.Column(scale=2, min_width=300):
+                    # gr.Dropdown(
+                    #     ["day", "week", "bird"], label="Select time range", info="Will add more animals later!"
+                    # ),
+                    date_choice = gr.Radio(["day", "week", "all"], label="Select Time Range", value="day")
+                    date_button = gr.Button("Confirm")
+                papers_text = gr.Textbox(label="Trend Papers", interactive=False, scale=8, lines=5, max_lines=5)
+
+            with gr.Row():
+                topic_text = gr.Textbox(label="Topic Trend", interactive=False, scale=5, lines=7, max_lines=10)
+
+                ideas_text = gr.Textbox(label="Ideas Related to Topic Trend", interactive=False, scale=5, lines=7, max_lines=10)
+
+        date_button.click(confirm_date, inputs=[date_choice, profile_text], outputs=[topic_text, papers_text, ideas_text])
+
+    with gr.Accordion("Chat with Arxiv Copilot!", open=True):
+        gr.Markdown(
+            """
+            Each time we will give you two answers. If you prefer the second answer, you can click 👍 below the second answer and the first answer will be removed. If you click 👎, the second answer will be removed. 
+            """
+        )
+        with gr.Column():
+            chatbot = gr.Chatbot()
+            with gr.Row():
+                msg = gr.Textbox(placeholder="Message Arxiv Copilot here...", scale=9, show_label=False)
+                send_button = gr.Button("Send",scale=1)  # Adding a Send button
+                clear = gr.ClearButton([msg, chatbot],scale=1)
+
+            
+
+
+        def print_like_dislike(x: gr.LikeData, chat_history):
+            cur_index = x.index[0]
+            if  cur_index >= 1 and chat_history[cur_index - 1][1] is None:
+                if x.liked:
+                    chat_history[cur_index - 1][1] = chat_history[cur_index][1]
+                    agent.update_feedback_thought(chat_history[cur_index - 1][0], chat_history[cur_index][0], chat_history[cur_index][1], 0, 1)
+                    # gr.Info("You like the second answer, and the fisrt answer will be removed.")
+
+                else:
+                    agent.update_feedback_thought(chat_history[cur_index - 1][0], chat_history[cur_index][0], chat_history[cur_index][1], 1, 0)
+                    chat_history[cur_index - 1][1] = chat_history[cur_index][0]
+                    # gr.Info("You dislike the second answer, and the second answer will be removed.")
+                chat_history.remove(chat_history[cur_index])
+            else:
+                gr.Info("You have gave your feedback. You can ask more questions.")
+            return chat_history
+
+
+
+        
+        msg.submit(respond, [msg, chatbot, profile_text], [msg, chatbot])    # Set up the action for the Send button
+        send_button.click(respond, inputs=[msg, chatbot, profile_text], outputs=[msg, chatbot])
+        chatbot.like(print_like_dislike, [chatbot], [chatbot])
+
+
+        with gr.Row():
+            comment_input = gr.Textbox(label="With Arxiv Copilot, how much time do you save to obtain the same amount of information?", scale=9, lines=3)
+            comment_button = gr.Button(value="Comment", scale=1)
+
+
+        comment_button.click(send_comment, inputs=comment_input, outputs=None)
+
+    
+
+app.launch()

arxiv_agent.py

@@ -0,0 +1,530 @@
+import os
+import pickle
+import json
+import time
+import datetime
+from xml.etree import ElementTree
+
+import requests
+import warnings
+warnings.filterwarnings("ignore")
+os.environ['KMP_DUPLICATE_LIB_OK']='True'
+from utils import *
+import thread6
+MAX_DAILY_PAPER = 200
+DAY_TIME = 60 * 60 * 24
+
+def feedback_thought(input_ls): # preload
+    agent, query, ansA, ansB, feedbackA, feedbackB = input_ls
+    filename_thought = agent.thought_path
+    filename = agent.feedback_path
+
+    date = agent.today
+
+    json_data = agent.feedback
+    json_data_thought = agent.thought
+
+    if date in json_data:
+        if query not in json_data[date]:
+            json_data[date][query] = {}
+    else:
+        json_data[date] = {}        
+        json_data[date][query] = {}
+
+    if date not in json_data_thought:
+        json_data_thought[date] = []        
+    
+    
+    json_data[date][query]["answerA"] = (ansA)
+    json_data[date][query]["feedbackA"] = feedbackA
+    json_data[date][query]["answerB"] = (ansB)
+    json_data[date][query]["feedbackB"] = feedbackB
+    with open(filename,"w") as f:
+        json.dump(json_data,f)
+
+    preferred_ans = ""
+    if feedbackA == 1:
+        new_knowledge = response_verify([query], [ansA], verify=False)
+        preferred_ans = ansA
+        # json_data_thought[date].append(query + ansA)
+    else:
+        new_knowledge = response_verify([query], [ansB], verify=False)
+        preferred_ans = ansB
+        # json_data_thought[date].append(query + ansB)
+
+    if ('idk' not in new_knowledge[0]):
+
+        new_knowledge_embedding = get_bert_embedding(new_knowledge)
+        thought_embedding_all = []
+        for k in agent.thought_embedding.keys():
+            thought_embedding_all.extend(agent.thought_embedding[k])
+
+        similarity = calculate_similarity(thought_embedding_all, new_knowledge_embedding[0])
+
+        similarity_values = [s.item() for s in similarity]  # Convert each tensor to a scalar
+        if all(s < 0.85 for s in similarity_values):
+            # self.update_feedback(an, answer_l_org, query)
+            tem_thought = query + preferred_ans
+            json_data_thought[date].append(tem_thought)
+            if date not in agent.thought_embedding:
+                agent.thought_embedding = {}
+                agent.thought_embedding[date] = [get_bert_embedding([tem_thought])[0]]
+            else:
+                agent.thought_embedding[date].append(get_bert_embedding([tem_thought])[0])
+
+            with open(filename_thought,"w") as f:
+                json.dump(json_data_thought,f)
+
+            with open(agent.thought_embedding_path, "wb") as f:
+                pickle.dump(agent.thought_embedding, f)
+
+    # return "Give feedback successfully!"
+
+def dailyDownload(agent_ls):
+
+    agent = agent_ls[0]
+    while True:
+        time.sleep(DAY_TIME)
+        data_collector = []
+        keywords = dict()
+        keywords["Machine Learning"] = "Machine Learning"
+
+        for topic,keyword in keywords.items():
+
+            data, agent.newest_day = get_daily_papers(topic, query = keyword, max_results = MAX_DAILY_PAPER)
+            data_collector.append(data)
+
+        json_file = agent.dataset_path
+
+        update_file=update_json_file(json_file, data_collector)
+
+        time_chunks_embed={}
+
+        for data in data_collector:
+            for date in data.keys():
+                papers = data[date]['abstract']
+                papers_embedding=get_bert_embedding(papers)
+                time_chunks_embed[date.strftime("%m/%d/%Y")] = papers_embedding
+        update_paper_file=update_pickle_file(agent.embedding_path,time_chunks_embed)
+        agent.paper = update_file
+        agent.paper_embedding = update_paper_file
+        print("Today is " + agent.newest_day.strftime("%m/%d/%Y"))
+
+
+
+
+
+class ArxivAgent:
+    def __init__(self):
+        
+        self.dataset_path = "./dataset/paper.json"
+        self.thought_path = "./dataset/thought.json"
+
+        self.embedding_path = "./dataset/paper_embedding.pkl"
+        self.thought_embedding_path = './dataset/thought_embedding.pkl'
+
+        self.feedback_path = 'dataset/feedback.json'
+        self.today = datetime.datetime.now().strftime("%m/%d/%Y")
+
+        self.newest_day = ""
+        self.load_thought()
+        self.load_feedback()
+        self.download()
+        try:
+            thread6.run_threaded(dailyDownload, [self])
+            # thread6.start_new_thread( print_time, ["Thread-2", 4] )
+        except:
+            print("Error: unable to start thread")
+        # self.paper = self.download()
+        # self.paper_by_date = self.paper
+    def edit_profile(self, profile, author_name):
+        profile = profile
+        filename = 'dataset/profile.json'
+        with open(filename, 'r', encoding='utf-8') as file:
+            data = json.load(file)
+        data[author_name]=profile
+        with open(filename, "w") as f:
+            json.dump(data, f)
+        return "Successfully edit profile!"
+    
+    def get_profile(self, author_name):
+        if author_name == "": return None
+        # import pdb
+        # pdb.set_trace()
+        profile = self.get_arxiv_data_by_author(author_name)
+        return profile
+    def select_date(self, method, profile_input):
+   
+        today = self.newest_day
+        chunk_embedding_date={}
+
+        
+        paper_by_date = {}
+        if method == "day":
+            offset_day = today 
+            str_day = offset_day.strftime("%m/%d/%Y")
+            if str_day in self.paper:
+                paper_by_date[str_day] = self.paper[str_day]
+                chunk_embedding_date[str_day]=self.paper_embedding[str_day]
+
+        elif method == "week":
+            for i in range(7):
+                offset_day = today - datetime.timedelta(days=i)
+                str_day = offset_day.strftime("%m/%d/%Y")
+                
+                if str_day in self.paper:
+                    # print(str_day)
+                    paper_by_date[str_day] = self.paper[str_day]
+                    chunk_embedding_date[str_day] = self.paper_embedding[str_day]
+        else:
+            # import pdb
+            # pdb.set_trace()
+            paper_by_date = self.paper
+            chunk_embedding_date=self.paper_embedding
+
+        dataset = paper_by_date
+        data_chunk_embedding=chunk_embedding_date
+        profile = profile_input
+
+        # trend, paper_link = summarize_research_field(profile, "Machine Learning", dataset) # trend
+        trend, paper_link = summarize_research_field(profile, "Machine Learning", dataset,data_chunk_embedding) # trend
+
+        # import pdb
+        # pdb.set_trace()
+        reference = papertitleAndLink(paper_link)
+        # print("Trend:", self.trend,"\n")
+        idea = generate_ideas(trend) # idea
+
+        key_update = list(self.paper.keys())[-1]
+        if key_update not in self.thought:
+            self.thought[key_update] = []
+        if key_update not in self.thought_embedding:
+            self.thought_embedding[key_update] = []
+
+        self.thought[key_update].append(trend[0])
+        self.thought_embedding[key_update].append(get_bert_embedding([trend])[0])
+        self.thought[key_update].append(idea[0])
+        self.thought_embedding[key_update].append(get_bert_embedding([idea])[0])
+        # with open(self.dataset_path, "w") as f_:
+        #     json.dump(self.paper, f_)
+
+        with open(self.thought_path, "w") as f_:
+            json.dump(self.thought, f_)
+
+        with open(self.thought_embedding_path, "wb") as f:
+            pickle.dump(self.thought_embedding, f)
+
+
+        return trend, reference, idea
+
+    def response(self, data, profile_input):
+        # dataset = self.paper_by_date
+
+        # dataset = self.paper
+        query = [data]
+        profile = profile_input
+
+        query_embedding=get_bert_embedding(query)
+
+
+        retrieve_text,retrieve_text_org=self.generate_pair_retrieve_text(query_embedding)
+
+        context,context_org = [retrieve_text],[retrieve_text_org]
+
+        answer_l = get_response_through_LLM_answer(query, context,profile)
+        answer_l_org = get_response_through_LLM_answer(query, context_org, profile)
+
+
+
+        return answer_l,answer_l_org
+
+    def generate_pair_retrieve_text(self, query_embedding):
+        # Access dataset
+        dataset = self.paper
+        thought = self.thought
+
+        text_chunk_l = []
+        chunks_embedding_text_all = []
+
+        text_org_chunk_l = []
+        chunks_org_embedding_text_all = []
+
+        # Include all text chunks and their embeddings
+        for k in dataset.keys():
+            text_chunk_l.extend(dataset[k]['abstract'])
+            chunks_embedding_text_all.extend(self.paper_embedding[k])
+
+            text_org_chunk_l.extend(dataset[k]['abstract'])
+            chunks_org_embedding_text_all.extend(self.paper_embedding[k])
+            
+        for k in thought.keys():
+            if k in self.thought_embedding.keys():
+                text_chunk_l.extend(thought[k])
+                chunks_embedding_text_all.extend(self.thought_embedding[k])
+
+
+        # Include thoughts if not excluded
+
+        neib_all = neiborhood_search(chunks_embedding_text_all, query_embedding, num=10)
+        neib_all = neib_all.reshape(-1)
+        # import pdb
+        # pdb.set_trace()
+        # Compile retrieved text
+        # import pdb
+        # pdb.set_trace()
+        retrieve_text = ''.join([text_chunk_l[i] for i in neib_all])
+
+        neib_all = neiborhood_search(chunks_org_embedding_text_all, query_embedding, num=10)
+        neib_all = neib_all.reshape(-1)
+        # Compile retrieved text
+        retrieve_text_org = ''.join([text_org_chunk_l[i] for i in neib_all])
+
+        return retrieve_text,retrieve_text_org
+
+    def download(self):
+        # key_word = "Machine Learning"
+        data_collector = []
+        keywords = dict()
+        keywords["Machine Learning"] = "Machine Learning"
+    
+        for topic,keyword in keywords.items():
+    
+            data, self.newest_day = get_daily_papers(topic, query = keyword, max_results = MAX_DAILY_PAPER)
+            data_collector.append(data)
+
+        json_file = self.dataset_path
+        if not os.path.exists(json_file):
+            with open(json_file,'w')as a:
+                print("create " + json_file)
+
+        update_file=update_json_file(json_file, data_collector)
+
+        if not os.path.exists(self.embedding_path):
+            with open(self.embedding_path,'wb')as a:
+                print("create " + self.embedding_path)
+        time_chunks_embed={}
+
+        for data in data_collector:
+            for date in data.keys():
+                papers = data[date]['abstract']
+                papers_embedding=get_bert_embedding(papers)
+                time_chunks_embed[date.strftime("%m/%d/%Y")] = papers_embedding
+        update_paper_file=update_pickle_file(self.embedding_path,time_chunks_embed)
+        self.paper = update_file
+        self.paper_embedding = update_paper_file
+
+    
+
+    def load_feedback(self):
+        filename = self.feedback_path
+
+        if os.path.exists(filename):
+            with open(filename,"rb") as f:
+                content = f.read()
+                if not content:
+                    m = {}
+                else:
+                    m = json.loads(content)
+        else:
+            with open(filename, mode='w', encoding='utf-8') as ff:
+                m = {}
+        self.feedback = m.copy()
+
+   
+
+
+    def load_thought(self):
+        filename = self.thought_path
+        filename_emb = self.thought_embedding_path
+
+        if os.path.exists(filename):
+            with open(filename,"rb") as f:
+                content = f.read()
+                if not content:
+                    m = {}
+                else:
+                    m = json.loads(content)
+        else:
+            with open(filename, mode='w', encoding='utf-8') as ff:
+                m = {}
+
+
+        if os.path.exists(filename_emb):
+            with open(filename_emb,"rb") as f:
+                content = f.read()
+                if not content:
+                    m_emb = {}
+                else:
+                    m_emb = pickle.loads(content)
+        else:
+            with open(filename_emb, mode='w', encoding='utf-8') as ff:
+                m_emb = {}
+
+        self.thought = m.copy() 
+        self.thought_embedding = m_emb.copy() 
+
+
+
+
+        # for date in self.thought.keys():
+        #     papers = data[time]['abstract']
+        #     papers_embedding=get_bert_embedding(papers)
+        #     time_chunks_embed[time.strftime("%m/%d/%Y")] = papers_embedding
+        # return 
+        # for k in json_data.keys():
+    def update_feedback_thought(self, query, ansA, ansB, feedbackA, feedbackB): 
+        try:
+            thread6.run_threaded(feedback_thought, [self, query, ansA, ansB, feedbackA, feedbackB])
+            # thread6.start_new_thread( print_time, ["Thread-2", 4] )
+        except:
+            print("Error: unable to start thread")
+
+       
+    def update_comment(self, comment):
+        date = datetime.datetime.now().strftime("%m/%d/%Y")
+
+        filename = 'dataset/comment.json'
+        if os.path.exists(filename):
+            with open(filename,"r") as f:
+                content = f.read()
+                if not content:
+                    m = {}
+                else:
+                    m = json.loads(content)
+        else:
+            with open(filename, mode='w', encoding='utf-8') as ff:
+                m = {}
+            
+                
+        json_data = m.copy() 
+
+        if date not in json_data:
+            json_data[date] = [comment]
+        else: json_data[date].append(comment) 
+
+        with open(filename,"w") as f:
+            json.dump(json_data,f)
+        return "Thanks for your comment!"
+    
+
+
+
+    def get_arxiv_data_by_author(self, author_name):
+
+
+
+        filename = 'dataset/profile.json'
+        if os.path.exists(filename):
+            with open(filename,"r") as f:
+                content = f.read()
+                if not content:
+                    m = {}
+                else:
+                    m = json.loads(content)
+        else:
+            with open(filename, mode='w', encoding='utf-8') as ff:
+                m = {}
+            
+                
+        json_data = m.copy() 
+
+        if author_name in json_data: return json_data[author_name]
+           
+        author_query = author_name.replace(" ", "+")
+        url = f"http://export.arxiv.org/api/query?search_query=au:{author_query}&start=0&max_results=300"  # Adjust max_results if needed
+
+        response = requests.get(url)
+        papers_list = []
+
+        if response.status_code == 200:
+            root = ElementTree.fromstring(response.content)
+            entries = root.findall('{http://www.w3.org/2005/Atom}entry')
+
+            total_papers = 0
+            data_to_save = []
+
+            papers_by_year = {}
+
+            for entry in entries:
+
+                title = entry.find('{http://www.w3.org/2005/Atom}title').text.strip()
+                published = entry.find('{http://www.w3.org/2005/Atom}published').text.strip()
+                abstract = entry.find('{http://www.w3.org/2005/Atom}summary').text.strip()
+                authors_elements = entry.findall('{http://www.w3.org/2005/Atom}author')
+                authors = [author.find('{http://www.w3.org/2005/Atom}name').text for author in authors_elements]
+                link = entry.find('{http://www.w3.org/2005/Atom}id').text.strip()  # Get the paper link
+
+                # Check if the specified author is exactly in the authors list
+                if author_name in authors:
+                    # Remove the specified author from the coauthors list for display
+                    coauthors = [author for author in authors if author != author_name]
+                    coauthors_str = ", ".join(coauthors)
+
+                    papers_list.append({
+                        "date": published,
+                        "Title & Abstract": f"{title}; {abstract}",
+                        "coauthors": coauthors_str,
+                        "link": link  # Add the paper link to the dictionary
+                    })
+                authors_elements = entry.findall('{http://www.w3.org/2005/Atom}author')
+                authors = [author.find('{http://www.w3.org/2005/Atom}name').text for author in authors_elements]
+
+                if author_name in authors:
+                    # print(author_name)
+                    # print(authors)
+                    total_papers += 1
+                    published_date = entry.find('{http://www.w3.org/2005/Atom}published').text.strip()
+                    date_obj = datetime.datetime.strptime(published_date, '%Y-%m-%dT%H:%M:%SZ')
+
+                    year = date_obj.year
+                    if year not in papers_by_year:
+                        papers_by_year[year] = []
+                    papers_by_year[year].append(entry)
+
+            if total_papers > 40:
+                for cycle_start in range(min(papers_by_year), max(papers_by_year) + 1, 5):
+                    cycle_end = cycle_start + 4
+                    for year in range(cycle_start, cycle_end + 1):
+                        if year in papers_by_year:
+                            selected_papers = papers_by_year[year][:2]
+                            for paper in selected_papers:
+                                title = paper.find('{http://www.w3.org/2005/Atom}title').text.strip()
+                                abstract = paper.find('{http://www.w3.org/2005/Atom}summary').text.strip()
+                                authors_elements = paper.findall('{http://www.w3.org/2005/Atom}author')
+                                co_authors = [author.find('{http://www.w3.org/2005/Atom}name').text for author in authors_elements if author.find('{http://www.w3.org/2005/Atom}name').text != author_name]
+
+                                papers_list.append({
+                                    "Author": author_name,
+                                    "Title & Abstract": f"{title}; {abstract}",
+                                    "Date Period": f"{year}",
+                                    "Cycle": f"{cycle_start}-{cycle_end}",
+                                    "Co_author": ", ".join(co_authors)
+                                })
+  
+
+
+
+            # Trim the list to the 10 most recent papers
+            papers_list = papers_list[:10]
+
+            # Prepare the data dictionary with the author's name as a key
+            # import pdb
+            # pdb.set_trace()
+            personal_info = "; ".join([f"{details['Title & Abstract']}" for details in papers_list])
+            info = summarize_research_direction(personal_info)
+            json_data[author_name] = info
+            with open(filename,"w") as f:
+                json.dump(json_data,f)
+            return json_data[author_name]
+
+            # data = {author_name: {"paper_{}".format(i+1): paper for i, paper in enumerate(papers_list)}}
+
+        else:
+            # print("Failed to fetch data from arXiv.")
+            return None
+
+
+
+
+
+    

requirements.txt

@@ -0,0 +1,7 @@
+torch
+faiss-cpu
+transformers
+arxiv
+requests
+openai==0.28
+thread6

utils.py

@@ -0,0 +1,740 @@
+import os
+import numpy as np
+import openai
+import faiss
+from transformers import BertTokenizer, BertModel
+import torch
+import json
+import time
+import warnings
+import copy
+import pickle
+import random
+import torch.nn.functional as F
+
+seed_value = 42 
+random.seed(seed_value)
+np.random.seed(seed_value)
+torch.manual_seed(seed_value)
+
+warnings.filterwarnings("ignore")
+os.environ['KMP_DUPLICATE_LIB_OK'] = 'True'
+
+
+KEY = os.environ['API_KEY']
+openai.api_base = 'https://api.together.xyz'
+llm_model = "mistralai/Mixtral-8x7B-Instruct-v0.1"
+
+tokenizer = BertTokenizer.from_pretrained('facebook/contriever')
+model = BertModel.from_pretrained('facebook/contriever').to(torch.device("cpu"))
+
+import datetime
+import json
+import arxiv
+
+def summarize_research_direction(personal_info):
+    prompt_qa = (
+    "Based on the list of the researcher's first person persona from different times, please write a comprehensive first person persona. Focus more on more rescent personas. Be concise and clear (around 300 words)."
+    "Here are the personas from different times: {peronalinfo}"
+    )
+
+    openai.api_key = KEY
+    input = {}
+    input['peronalinfo'] = personal_info
+    prompt = prompt_qa.format_map(input)
+    try:
+        completion = openai.ChatCompletion.create(
+            model=llm_model,
+            messages=[
+                {"role": "user", "content": prompt}], temperature=0.6,seed = 42, top_p=0)
+    except:
+        time.sleep(20)
+        completion = openai.ChatCompletion.create(
+            model=llm_model,
+            messages=[
+                {"role": "user", "content": prompt}], temperature=0.6,seed = 42, top_p=0)
+    content = completion.choices[0].message["content"]
+    return content
+
+def get_authors(authors, first_author = False):
+    output = str()
+    if first_author == False:
+        output = ", ".join(str(author) for author in authors)
+    else:
+        output = authors[0]
+    return output
+def sort_papers(papers):
+    output = dict()
+    keys = list(papers.keys())
+    keys.sort(reverse=True)
+    for key in keys:
+        output[key] = papers[key]
+    return output    
+
+def get_daily_papers(topic,query="slam", max_results=300):
+    """
+    @param topic: str
+    @param query: str
+    @return paper_with_code: dict
+    """
+
+    # output 
+    content = dict() 
+    Info = dict() 
+    search_engine = arxiv.Search(
+        query = query,
+        max_results = max_results,
+        sort_by = arxiv.SortCriterion.SubmittedDate
+    )
+    newest_day = None
+    # cnt = 0
+    for result in search_engine.results():
+
+        # paper_id       = result.get_short_id()
+        paper_title    = result.title
+        paper_url      = result.entry_id
+        # paper_abstract = result.summary
+        
+        paper_abstract = result.summary.replace("\n"," ")
+
+
+        publish_time = result.published.date()
+        if newest_day is not None and not(newest_day == publish_time):
+
+            break
+        elif newest_day is None:
+            newest_day = publish_time
+        
+
+        if publish_time in content:
+            content[publish_time]['abstract'].append(paper_title+ ": "+paper_abstract)
+            content[publish_time]['info'].append(paper_title+": "+paper_url)
+            # Info[publish_time].append(paper_title+": "+paper_url)
+        else:
+            content[publish_time] = {}
+            content[publish_time]['abstract'] = [paper_title+ ": "+paper_abstract]
+            content[publish_time]['info'] = [paper_title+": "+paper_url]
+        # cnt = cnt + 1
+            # content[publish_time] = [paper_abstract]
+            # Info[publish_time] = 
+        # print(publish_time)
+        # content[paper_key] = f"|**{publish_time}**|**{paper_title}**|{paper_first_author} et.al.|[{paper_id}]({paper_url})|\n"
+    data = content
+    # print(cnt)
+    
+    return data, newest_day
+def papertitleAndLink(dataset):
+    formatted_papers = []
+    i = 0
+    # import pdb
+    # pdb.set_trace()
+    for title in dataset:
+        
+            # import pdb
+            # pdb.set_trace()
+        i = i +1
+        formatted_papers.append("[%d] "%i + title) 
+    # i = 0
+    # formatted_papers = [f"{"[%d]"%i + papers}" i = i + 1 for k in dataset.keys() for papers in dataset[k]['info']]
+    return ';\n'.join(formatted_papers)
+
+def paperinfo(dataset):
+    # for k in dataset.keys():
+    formatted_papers = [f"{paper}" for k in dataset.keys() for paper in dataset[k]['abstract']]
+    return '; '.join(formatted_papers)
+
+def generate_ideas (trend):
+    # prompt_qa = (
+    #    "Now you are a researcher with this background {profile}, and here is a high-level summarized trend of a research field {trend}."
+    #    "How do you view this field? Do you have any novel ideas or insights?"
+    # )
+
+    prompt_qa = (
+       "Here is a high-level summarized trend of a research field: {trend}."
+       "How do you view this field? Do you have any novel ideas or insights?"
+       "Please give me 3 to 5 novel ideas and insights in bullet points. Each bullet points should be concise, containing 2 or 3 sentences."
+    )
+
+    openai.api_key = KEY
+    content_l = []
+    input = {}
+    # input['profile'] = profile
+    input['trend'] = trend
+    prompt = prompt_qa.format_map(input)
+    try:
+        completion = openai.ChatCompletion.create(
+            model=llm_model,
+            messages=[
+                {"role": "user", "content": prompt}], temperature=0.6,seed = 42, top_p=0)
+    except:
+        time.sleep(20)
+        completion = openai.ChatCompletion.create(
+            model=llm_model,
+            messages=[
+                {"role": "user", "content": prompt}], temperature=0.6,seed = 42, top_p=0)
+    content = completion.choices[0].message["content"]
+    content_l.append(content)
+    return content_l
+
+def summarize_research_field(profile, keywords, dataset,data_embedding):
+    # papers = paperinfo(dataset)
+    query_input = {}
+    input = {}
+    if profile is None: 
+        prompt_qa = (
+        "Given the keywords, some recent paper titles and abstracts. Could you summarize no more than 10 top keywords of high level research backgounds and trends in this field."
+        "Here are the keywords: {keywords}"
+        "Here are the retrieved paper abstracts: {papers}"
+        )
+        query_format = (
+        "Given the keywords, retrieve some recent paper titles and abstracts can represent research trends in this field."
+        "Here are the keywords: {keywords}"
+        )
+        input['keywords'] = keywords
+        query_input['keywords'] = keywords
+    else:
+        prompt_qa = (
+        "Given the profile of me, some recent paper titles and abstracts. Could you summarize no more than 10 top keywords of high level research backgounds and trends in this field (related to my profile)."
+        "Here is my profile: {profile}"
+        # "Here are the keywords: {keywords}"
+        "Here are the retrieved paper abstracts: {papers}"
+        )
+        query_format = (
+        "Given the profile of me, retrieve some recent paper titles and abstracts can represent research trends related to my profile."
+        "Here is my profile: {profile}"
+        # "Here are the keywords: {keywords}"
+        )
+        input['profile'] = profile
+        query_input['profile'] = profile
+        # import pdb
+        # pdb.set_trace()
+    openai.api_key = KEY
+    content_l = []
+    
+    
+
+
+    query = query_format.format_map(query_input)
+
+    query_embedding=get_bert_embedding([query])
+    # text_chunk_l = dataset
+    text_chunk_l = []
+    data_embedding_l=[]
+
+    # with open(dataset_path, 'r', encoding='utf-8') as file:
+    #     dataset = json.load(file)
+    title_chunk = []
+    for k in dataset.keys():
+        # import pdb
+        # pdb.set_trace()
+        title_chunk.extend(dataset[k]['info'])
+        text_chunk_l.extend(dataset[k]['abstract'])
+        data_embedding_l.extend(data_embedding[k])
+        # import pdb
+        # pdb.set_trace()
+        # print(dataset[k]['info'])
+
+    # [p if 'graph' in p else "" for p in dataset[k]['info']]
+    chunks_embedding_text_all = data_embedding_l
+    ch_text_chunk=copy.copy(text_chunk_l)
+    ch_text_chunk_embed=copy.copy(chunks_embedding_text_all)
+    num_chunk = 10
+    # print("raw_chunk_length: ", raw_chunk_length)
+
+    neib_all = neiborhood_search(ch_text_chunk_embed, query_embedding, num_chunk)
+
+    neib_all=neib_all.reshape(-1)
+
+    context = []
+    retrieve_paper = []
+
+    for i in neib_all:
+        context.append(ch_text_chunk[i])
+        # if i not in retrieve_paper:
+        retrieve_paper.append(title_chunk[i])
+    # import pdb
+    # pdb.set_trace()
+    input['papers'] = '; '.join(context)
+    prompt = prompt_qa.format_map(input)
+    # import pdb
+    # pdb.set_trace()
+    # import pdb
+    # pdb.set_trace()
+    
+    
+    try:
+        completion = openai.ChatCompletion.create(
+            model=llm_model,
+            messages=[
+                {"role": "user", "content": prompt}],   max_tokens=512)
+    except:
+        time.sleep(20)
+        completion = openai.ChatCompletion.create(
+            model=llm_model,
+            messages=[
+                {"role": "user", "content": prompt}],   max_tokens= 512)
+    content = completion.choices[0].message["content"]
+    content_l.append(content)
+    return content_l, retrieve_paper
+def update_json_file(filename,data_all):
+    with open(filename,"r") as f:
+        content = f.read()
+        if not content:
+            m = {}
+        else:
+            m = json.loads(content)
+            
+    json_data = m.copy() 
+    
+    # update papers in each keywords         
+    for data in data_all:
+        for time in data.keys():
+            papers = data[time]
+            # print(papers.published)
+            json_data[time.strftime("%m/%d/%Y")] = papers
+    for time in json_data.keys():
+        papers = json_data[time]
+        papers['ch_abs']=copy.deepcopy(papers['abstract'])
+        # print(papers.published)
+        json_data[time] = papers
+    with open(filename,"w") as f_:
+        json.dump(json_data,f_)
+    return json_data
+
+def update_pickle_file(filename, data_all):
+
+    # if os.path.exists(filename):
+        # with open(filename,"rb") as f:
+        #     m = pickle.loads(f)
+    # with open(filename,"rb") as f:
+    #     content = f.read()
+    #     if not content:
+    #         m = {}
+    #     else:
+    #         m = json.load(content)
+    with open(filename, "rb") as file:
+        m = pickle.load(file)        
+    # json_data = m.copy() 
+    # else:
+    #     with open(filename, mode='wb', encoding='utf-8') as ff:
+    #         m = {}
+
+    # with open(filename, "rb") as file:
+    #     m = pickle.load(file)
+    pickle_data = m.copy()
+
+    for time in data_all.keys():
+        embeddings = data_all[time]
+        pickle_data[time] =embeddings
+    with open(filename, "wb") as f:
+        pickle.dump(pickle_data, f)
+
+    return pickle_data
+def json_to_md(filename):
+    """
+    @param filename: str
+    @return None
+    """
+    
+    DateNow = datetime.date.today()
+    DateNow = str(DateNow)
+    DateNow = DateNow.replace('-','.')
+    
+    with open(filename,"r") as f:
+        content = f.read()
+        if not content:
+            data = {}
+        else:
+            data = json.loads(content)
+
+    md_filename = "README.md"  
+      
+    # clean README.md if daily already exist else create it
+    with open(md_filename,"w+") as f:
+        pass
+
+    # write data into README.md
+    with open(md_filename,"a+") as f:
+  
+        f.write("## Updated on " + DateNow + "\n\n")
+        
+        for keyword in data.keys():
+            day_content = data[keyword]
+            if not day_content:
+                continue
+            # the head of each part
+            f.write(f"## {keyword}\n\n")
+            f.write("|Publish Date|Title|Authors|PDF|\n" + "|---|---|---|---|\n")
+            # sort papers by date
+            day_content = sort_papers(day_content)
+        
+            for _,v in day_content.items():
+                if v is not None:
+                    f.write(v)
+
+            f.write(f"\n")
+    print("finished")   
+
+
+
+def neiborhood_search(corpus_data, query_data, num=8):
+    d = 768  # dimension
+    neiborhood_num = num
+    xq = torch.cat(query_data, 0).cpu().numpy()
+    xb = torch.cat(corpus_data, 0).cpu().numpy()
+    index = faiss.IndexFlatIP(d)
+    xq = xq.astype('float32')
+    xb = xb.astype('float32')
+    faiss.normalize_L2(xq)
+    faiss.normalize_L2(xb)
+    index.add(xb)  # add vectors to the index
+    D, I = index.search(xq, neiborhood_num)
+
+    return I
+
+
+
+
+def get_passage_conclusion_through_LLM(text, question):
+    # prompt_qa = ("Given text:{context},given question:{question},based on this text and question, summarize the above text into a passage so that it can best answer this question.")
+    prompt_qa = (
+        "Given text:{context},based on this text, summarize the above text into a passage that cannot change its original meaning.")
+    openai.api_key = KEY
+
+    input = {}
+    input['context'] = text
+    input['question'] = question
+    prompt = prompt_qa.format_map(input)
+    try:
+        completion = openai.ChatCompletion.create(
+            model=llm_model,
+            messages=[
+                {"role": "user", "content": prompt}], temperature=0.6, seed = 42)
+    except:
+        time.sleep(20)
+        completion = openai.ChatCompletion.create(
+            model=llm_model,
+            messages=[
+                {"role": "user", "content": prompt}], temperature=0.6, seed =42)
+    content = completion.choices[0].message["content"]
+    # print(content)
+    return content
+
+
+def retain_useful_info(text, question):
+    prompt_qa = (
+        "Given text:{context},given question:{question},based on this text and question, summarize the text into a sentence  that is most useful in answering this question.")
+    openai.api_key = KEY
+
+    input = {}
+    input['context'] = text
+    input['question'] = question
+    prompt = prompt_qa.format_map(input)
+    try:
+        completion = openai.ChatCompletion.create(
+            model=llm_model,
+            messages=[
+                {"role": "user", "content": prompt}])
+    except:
+        time.sleep(20)
+        completion = openai.ChatCompletion.create(
+            model=llm_model,
+            messages=[
+                {"role": "user", "content": prompt}])
+    content = completion.choices[0].message["content"]
+    # print(content)
+    return content
+
+
+def llm_summary(text_l):
+    # prompt_qa = ("Given text:{context},given question:{question},based on this text and question, summarize the above text into a passage so that it can best answer this question.")
+    text = ''
+    for inter in text_l:
+        text += inter
+    prompt_qa = (
+        "Given text:{context},based on this text, summarize the above text into a fluent passage that cannot change its original meaning.")
+    openai.api_key = KEY
+
+    input = {}
+    input['context'] = text
+    prompt = prompt_qa.format_map(input)
+    try:
+        completion = openai.ChatCompletion.create(
+            model=llm_model,
+            messages=[
+                {"role": "user", "content": prompt}], temperature=0.6, seed =42)
+    except:
+        time.sleep(20)
+        completion = openai.ChatCompletion.create(
+            model=llm_model,
+            messages=[
+                {"role": "user", "content": prompt}], temperature=0.6, seed=42)
+    content = completion.choices[0].message["content"]
+    # print(content)
+    return content
+
+
+def get_multi_query_through_LLM(question_data, generated_answers=None, support_material=None):
+    PROMPT_DICT = {
+        "without_answer": (
+            "The input will be a paragraph of text."
+            "Your task is to generate five as diverse, informative, and relevant, as possible versions of supporting materials, perspectives, fact. Provide these alternative materials, perspectives, fact. Each of them occupies a line."
+            "Original text: {question}"
+            "Answer:,Please output a list to split these five answers."),
+        "with_answer": (
+            "The input will be a paragraph of original text, a previously generated support material and a response for the text based on reviously generated support material  by a naive agent, who may make mistakes."
+            "Your task is to generate five as diverse, informative, and relevant, as possible versions of supporting materials,perspectives, fact based on the the above information. Each of them occupies a line."
+            "Provide these alternative materials, perspectives, fact."
+            "Original text:{question}. "
+            "Previously generated support material (the text below are naive, and could be wrong, use with caution): {support_material} "
+            "Response:{answer}."
+            "Answer:,Please output a list to split these five answers."),
+    }
+    prompt_q, prompt_qa = PROMPT_DICT["without_answer"], PROMPT_DICT["with_answer"]
+    openai.api_key = KEY
+    ### question_data
+    inter = {}
+    inter['question'] = question_data
+    if generated_answers != None:
+        inter['answer'] = generated_answers
+        inter['support_material'] = support_material
+        prompt = [prompt_qa.format_map(example) for example in [inter]]
+    else:
+        prompt = [prompt_q.format_map(example) for example in [inter]]
+    try:
+        completion = openai.ChatCompletion.create(
+            model=llm_model,
+            messages=[
+                {"role": "user", "content": prompt[0]}], temperature=0.6, seed=42)
+    except:
+        time.sleep(20)
+        completion = openai.ChatCompletion.create(
+            model=llm_model,
+            messages=[
+                {"role": "user", "content": prompt[0]}], temperature=0.6,seed =42)
+    content = completion.choices[0].message["content"]
+    for inter_ in content:
+        inter_ = inter_.strip('1.').strip('2.').strip('3.').strip('4.').strip('5.')
+    # print(content)
+
+    return content
+
+
+def get_question_through_LLM(question, context):
+    prompt_s = question[0]
+    for i in range(len(context)):
+        prompt_s += "Documents %d: " % (i + 1) + context[i] + '\n'
+
+    prompt_qa = (prompt_s)
+
+    openai.api_key = KEY
+    content_l = []
+    # import pdb
+    # pdb.set_trace()
+    # for inter1 in range(len(context)):
+
+    # question_i = question[0]
+    # context_i=context[inter1]
+    # input={}
+    # input['question']=question_i
+    # input['context']=context_i
+    prompt = prompt_qa
+    try:
+        completion = openai.ChatCompletion.create(
+            model=llm_model,
+            messages=[
+                {"role": "user", "content": prompt}], temperature=0.6, seed=42)
+    except:
+        time.sleep(20)
+        completion = openai.ChatCompletion.create(
+            model=llm_model,
+            messages=[
+                {"role": "user", "content": prompt}], temperature=0.6, seed=42)
+    content = completion.choices[0].message["content"]
+    content_l.append(content)
+    # print(content)
+    return content_l
+
+
+def get_response_through_LLM(question, context):
+    prompt_qa = ("Given text: {context}, based on this text, answer the question: {question}")
+    openai.api_key = KEY
+    content_l = []
+    # print(len(context))
+    # import pdb
+    # pdb.set_trace()
+    # print()
+
+    for inter1 in range(len(question)):
+        question_i = question[inter1]
+        context_i = context[inter1]
+        input = {}
+        input['question'] = question_i
+        input['context'] = context_i
+        prompt = prompt_qa.format_map(input)
+        # print(prompt)
+        try:
+            completion = openai.ChatCompletion.create(
+                model=llm_model,
+                messages=[
+                    {"role": "user", "content": prompt}], temperature=0.6,seed=42)
+        except:
+            time.sleep(20)
+            completion = openai.ChatCompletion.create(
+                model=llm_model,
+                messages=[
+                    {"role": "user", "content": prompt}], temperature=0.6,seed=42)
+        content = completion.choices[0].message["content"]
+        content_l.append(content)
+        # print("Answer for Pre Queston ", inter1, ": ")
+        # print(content,"\n")
+    return content_l
+
+def get_response_through_LLM_answer(question, context, profile):
+    # import pdb
+    # pdb.set_trace()
+    if profile is None:
+        prompt_qa = (
+            "Answer the: {question}, based on materials: {context}"
+        )
+    else:
+        prompt_qa = (
+            "Answer the: {question}, based on materials: {context} and my profile: {profile}"
+        )
+    openai.api_key = KEY
+    content_l = []
+    # print(len(context))
+    # import pdb
+    # pdb.set_trace()
+    # print()
+    
+    # print("Length of the question: ", len(question))
+    # print("Length of the context: ", len(context))
+
+    for inter1 in range(len(question)):
+
+        question_i = question[inter1]
+        context_i = context[inter1]
+        
+            
+        input = {}
+        input['question'] = question_i
+        input['context'] = context_i
+        if profile is not None:
+            profile_i = profile
+            input['profile'] = profile_i
+            # import pdb
+            # pdb.set_trace()
+        prompt = prompt_qa.format_map(input)
+        # print(prompt)
+        try:
+            completion = openai.ChatCompletion.create(
+                model=llm_model,
+                messages=[
+                    {"role": "user", "content": prompt}], temperature=0.6,seed=42)
+        except:
+            time.sleep(20)
+            completion = openai.ChatCompletion.create(
+                model=llm_model,
+                messages=[
+                    {"role": "user", "content": prompt}], temperature=0.6,seed=42)
+        content = completion.choices[0].message["content"]
+        content_l.append(content)
+        # print(content)
+    return content_l
+
+def get_response_through_LLM_cross(question, context):
+
+    prompt_s = context + '\n'
+ 
+    prompt_s += "Based on the above documents, answer the question: {question} in short."
+    prompt_qa = (prompt_s)
+
+    openai.api_key = KEY
+    content_l = []
+    for inter1 in range(len(question)):
+
+        question_i = question[inter1]
+        input = {}
+        input['question'] = question_i
+        prompt = prompt_qa.format_map(input)
+        try:
+            completion = openai.ChatCompletion.create(
+                model=llm_model,
+                messages=[
+                    {"role": "user", "content": prompt}], temperature=0.6,seed=42)
+        except:
+            time.sleep(20)
+            completion = openai.ChatCompletion.create(
+                model=llm_model,
+                messages=[
+                    {"role": "user", "content": prompt}], temperature=0.6,seed=42)
+        content = completion.choices[0].message["content"]
+        content_l.append(content)
+        # print(content)
+    return content_l
+
+
+def get_bert_embedding(instructions):
+
+
+    # encoded_input_all = [tokenizer(text['instruction']+text['input'], return_tensors='pt').to(torch.device("cuda")) for text in instructions]
+
+    encoded_input_all = [tokenizer(text, return_tensors='pt', truncation=True,
+                                   max_length=512).to(torch.device("cpu")) for text in instructions]
+
+    with torch.no_grad():
+        emb_list = []
+        for inter in encoded_input_all:
+            emb = model(**inter)
+            emb_list.append(emb['last_hidden_state'].mean(1))
+    return emb_list
+
+def calculate_similarity(tensor_list, input_tensor):
+    flattened_list = [t.flatten() for t in tensor_list]
+    flattened_tensor = input_tensor.flatten()
+    cosine_similarities = [F.cosine_similarity(flattened_tensor.unsqueeze(0), t.unsqueeze(0)) for t in flattened_list]
+
+    return cosine_similarities
+
+def response_verify(question, context, verify = False):
+    if verify:
+        prompt_qa = (
+            "Input: Given question:{question}, given answer:{context}. Based on the provided question and its corresponding answer, perform the following steps:"
+            "Step 1: Determine if the answer is an actual answer or if it merely indicates that the question cannot be answered due to insufficient information. If the latter is true, just output 'idk' without any extra words "
+            "Step 2: If it is a valid answer, succinctly summarize both the question and answer into a coherent knowledge point, forming a fluent passage."
+        )
+    else:
+        prompt_qa = (
+            "Given question:{question},given answer:{context},based on the given question and corresponding answer, "
+            "summarize them into a knowledge point like a fluent passage.")
+
+    openai.api_key = KEY
+    content_l = []
+
+    for inter1 in range(len(question)):
+
+        question_i = question[inter1]
+        context_i = context[inter1]
+        input = {}
+        input['question'] = question_i
+        input['context'] = context_i
+        prompt = prompt_qa.format_map(input)
+        # print(prompt)
+        try:
+            completion = openai.ChatCompletion.create(
+                model=llm_model,
+                messages=[
+                    {"role": "user", "content": prompt}], temperature=0.6,seed=42)
+        except:
+            time.sleep(20)
+            completion = openai.ChatCompletion.create(
+                model=llm_model,
+                messages=[
+                    {"role": "user", "content": prompt}], temperature=0.6,seed=42)
+        content = completion.choices[0].message["content"]
+        content_l.append(content)
+        # print(content)
+    return content_l
+
+