Refactoring gemini functions (#9)

- Refactoring gemini functions (b483e15951ebe8673817778370aa68a016fa09fa)


Co-authored-by: Trương Tấn Cường <[email protected]>

.gitattributes

@@ -1,35 +1,37 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+arxivdb/chroma.sqlite3 filter=lfs diff=lfs merge=lfs -text
+models/models--jinaai--jina-embeddings-v2-base-en/blobs/6b70f1386f05b9703ea4edf7f1550a8925399f9580e4cc754cc099efc1e736d8 filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -1,7 +1,5 @@
-arxivdb/
-models/
-__pycache__/
-*.pyc
-apikey.txt
-db.sqlite3
+models/
+__pycache__/
+*.pyc
+apikey.txt
 hotfix.ipynb

arxivdb/4b0c8007-4402-4129-b225-8bd2a39f0757/data_level0.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8d96c82cf4183e567eddf45be92064c7d818268621da9821caa2367bb20cba18
+size 32120000

arxivdb/4b0c8007-4402-4129-b225-8bd2a39f0757/header.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a494575edafaafb2b60f5a2ad563719976abf7ae3a35ca7c9b5aaae36842006c
+size 100

arxivdb/4b0c8007-4402-4129-b225-8bd2a39f0757/index_metadata.pickle

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:91e4880dca7113b4c3a3644e63aa5809f4a30474d1332f66d5f0ad082fe41833
+size 357939

arxivdb/4b0c8007-4402-4129-b225-8bd2a39f0757/length.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:814d4b3244fb0f86f8d5beac519239863d973c20c8fec45624d0c0ae54baf9cf
+size 40000

arxivdb/4b0c8007-4402-4129-b225-8bd2a39f0757/link_lists.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d679f3012c3a4ae23e21dbfce89bb153cab85edef4c19f5340a4464e99f4c014
+size 87396

arxivdb/6a7f20ca-1ffd-40b4-9707-7d9628097d5a/data_level0.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:31ea31ff76723407f460b7534220ef974bfb3a563732c1a85e01fd9b2610dc13
+size 6424000

arxivdb/6a7f20ca-1ffd-40b4-9707-7d9628097d5a/header.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:db5064bd751b93036fa600922f99c2534c183c3335c5267c8c5413a73f450320
+size 100

arxivdb/6a7f20ca-1ffd-40b4-9707-7d9628097d5a/index_metadata.pickle

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cd938c16ea62b22a52094297d5d570442daba226ad67e941b0254655e843c67a
+size 65937

arxivdb/6a7f20ca-1ffd-40b4-9707-7d9628097d5a/length.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9d9d14a589aeeaf2e86552f9c3f1bb4f556e49244f186540c71bac6c1680e834
+size 8000

arxivdb/6a7f20ca-1ffd-40b4-9707-7d9628097d5a/link_lists.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3751bd54da338722a3b5370921bf446e34169a639a18beb7145e5d4e9e3778e3
+size 18268

arxivdb/7e557f5a-be88-4080-aa85-e3bcd927fcf9/data_level0.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:86e41597eb04379b7582da7eeb5fb0aaca29eb32749069e69886358370fab575
+size 3212000

arxivdb/7e557f5a-be88-4080-aa85-e3bcd927fcf9/header.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fdb00e89b6ee7733fd37556b1da3447d9895ad7431512096c0e073ed667a25d0
+size 100

arxivdb/7e557f5a-be88-4080-aa85-e3bcd927fcf9/index_metadata.pickle

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cd5b11142a96276baf9591e9524a8d9241eb013902301021dddea3a81b61d63a
+size 33934

arxivdb/7e557f5a-be88-4080-aa85-e3bcd927fcf9/length.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e680a6fe8d1f2bf76260963cf27e0c7bd58c39e9c82262906a285eaf89b1c27d
+size 4000

arxivdb/7e557f5a-be88-4080-aa85-e3bcd927fcf9/link_lists.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:666164435753a1784160baf485cc1c80e665103e6bd19a1998430f93246f1c29
+size 8624

arxivdb/951c5fab-677a-4406-b99b-b4006c3423a2/data_level0.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ecac6a0b1c9974d085507909895bec9040788bd20bf184eae140000cef97551d
+size 38544000

arxivdb/951c5fab-677a-4406-b99b-b4006c3423a2/header.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:269f137da42a494d996ad44046f5e349b59d2d31eca4b39aa82d7ec76f62cdf9
+size 100

arxivdb/951c5fab-677a-4406-b99b-b4006c3423a2/index_metadata.pickle

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:08461957df6b58835618a34c77a9c96b6dc54f21e04c60c9d10dd36d5b864414
+size 429953

arxivdb/951c5fab-677a-4406-b99b-b4006c3423a2/length.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e648660e0a36f652356dd7e0210b243cba14b3b7c267c3c05fdc7614b1d2dd03
+size 48000

arxivdb/951c5fab-677a-4406-b99b-b4006c3423a2/link_lists.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:13b650da98a6bd2ec371437494a2cb09a2fae5b67d6eead12af43b40fb548e7c
+size 104644

arxivdb/chroma.sqlite3

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0c48f817474996b45a3f4da1e127a2fde083db4bfeddb71893d598b8200fb056
+size 123736064

chat/__init__.py

@@ -3,7 +3,7 @@ import chat.arxiv_bot.arxiv_bot_utils as utils
 import os
 from getpass import getpass
 import json
-from .model_manage import get_model
+# from .model_manage import get_model
 
-model = get_model()
+# model = get_model()
 

chat/arxiv_bot/arxiv_bot_utils.py

@@ -1,276 +1,276 @@
-import chromadb
-from chromadb import Documents, EmbeddingFunction, Embeddings
-from transformers import AutoModel
-import json
-from numpy.linalg import norm
-import sqlite3
-import urllib
-from django.conf import settings
+# import chromadb
+# from chromadb import Documents, EmbeddingFunction, Embeddings
+# from transformers import AutoModel
+# import json
+# from numpy.linalg import norm
+# import sqlite3
+# import urllib
+# from django.conf import settings
 
 
-# this module act as a singleton class
+# # this module act as a singleton class
 
-class JinaAIEmbeddingFunction(EmbeddingFunction):
-    def __init__(self, model):
-        super().__init__()
-        self.model = model
+# class JinaAIEmbeddingFunction(EmbeddingFunction):
+#     def __init__(self, model):
+#         super().__init__()
+#         self.model = model
 
-    def __call__(self, input: Documents) -> Embeddings:
-        embeddings = self.model.encode(input)
-        return embeddings.tolist()
+#     def __call__(self, input: Documents) -> Embeddings:
+#         embeddings = self.model.encode(input)
+#         return embeddings.tolist()
 
-# instance of embedding_model
-embedding_model = AutoModel.from_pretrained('jinaai/jina-embeddings-v2-base-en',
-                                                trust_remote_code=True,
-                                                cache_dir='models')
+# # instance of embedding_model
+# embedding_model = AutoModel.from_pretrained('jinaai/jina-embeddings-v2-base-en',
+#                                                 trust_remote_code=True,
+#                                                 cache_dir='models')
 
-# instance of JinaAIEmbeddingFunction
-ef = JinaAIEmbeddingFunction(embedding_model)
+# # instance of JinaAIEmbeddingFunction
+# ef = JinaAIEmbeddingFunction(embedding_model)
 
-# list of topics
-topic_descriptions = json.load(open("topic_descriptions.txt")) 
-topics = list(dict.keys(topic_descriptions))
-embeddings = [embedding_model.encode(topic_descriptions[key]) for key in topic_descriptions]
-cos_sim = lambda a,b: (a @ b.T) / (norm(a)*norm(b))
+# # list of topics
+# topic_descriptions = json.load(open("topic_descriptions.txt")) 
+# topics = list(dict.keys(topic_descriptions))
+# embeddings = [embedding_model.encode(topic_descriptions[key]) for key in topic_descriptions]
+# cos_sim = lambda a,b: (a @ b.T) / (norm(a)*norm(b))
 
-def choose_topic(summary):
-    embed = embedding_model.encode(summary)
-    topic = ""
-    max_sim = 0.
-    for i,key in enumerate(topics):
-        sim = cos_sim(embed,embeddings[i])
-        if sim > max_sim:
-            topic = key
-            max_sim = sim
-    return topic
+# def choose_topic(summary):
+#     embed = embedding_model.encode(summary)
+#     topic = ""
+#     max_sim = 0.
+#     for i,key in enumerate(topics):
+#         sim = cos_sim(embed,embeddings[i])
+#         if sim > max_sim:
+#             topic = key
+#             max_sim = sim
+#     return topic
 
-def authors_list_to_str(authors):
-   """input a list of authors, return a string represent authors"""
-   text = ""
-   for author in authors:
-      text+=author+", "
-   return text[:-3]
+# def authors_list_to_str(authors):
+#    """input a list of authors, return a string represent authors"""
+#    text = ""
+#    for author in authors:
+#       text+=author+", "
+#    return text[:-3]
 
-def authors_str_to_list(string):
-    """input a string of authors, return a list of authors"""
-    authors = []
-    list_auth = string.split("and")
-    for author in list_auth:
-        if author != "et al.":
-            authors.append(author.strip())
-    return authors
+# def authors_str_to_list(string):
+#     """input a string of authors, return a list of authors"""
+#     authors = []
+#     list_auth = string.split("and")
+#     for author in list_auth:
+#         if author != "et al.":
+#             authors.append(author.strip())
+#     return authors
 
-def chunk_texts(text, max_char=400):
-  """
-  Chunk a long text into several chunks, with each chunk about 300-400 characters long,
-  but make sure no word is cut in half.
-  Args:
-      text: The long text to be chunked.
-      max_char: The maximum number of characters per chunk (default: 400).
-  Returns:
-      A list of chunks.
-  """
-  chunks = []
-  current_chunk = ""
-  words = text.split()
-  for word in words:
-    if len(current_chunk) + len(word) + 1 >= max_char:
-        chunks.append(current_chunk)
-        current_chunk = " "
-    else:
-      current_chunk += " " + word
-  chunks.append(current_chunk.strip())
-  return chunks
+# def chunk_texts(text, max_char=400):
+#   """
+#   Chunk a long text into several chunks, with each chunk about 300-400 characters long,
+#   but make sure no word is cut in half.
+#   Args:
+#       text: The long text to be chunked.
+#       max_char: The maximum number of characters per chunk (default: 400).
+#   Returns:
+#       A list of chunks.
+#   """
+#   chunks = []
+#   current_chunk = ""
+#   words = text.split()
+#   for word in words:
+#     if len(current_chunk) + len(word) + 1 >= max_char:
+#         chunks.append(current_chunk)
+#         current_chunk = " "
+#     else:
+#       current_chunk += " " + word
+#   chunks.append(current_chunk.strip())
+#   return chunks
 
-def trimming(txt):
-    start = txt.find("{")
-    end = txt.rfind("}")
-    return txt[start:end+1].replace("\n"," ")
+# def trimming(txt):
+#     start = txt.find("{")
+#     end = txt.rfind("}")
+#     return txt[start:end+1].replace("\n"," ")
 
-# crawl data
+# # crawl data
 
-def extract_tag(txt,tagname):
-    return txt[txt.find("<"+tagname+">")+len(tagname)+2:txt.find("</"+tagname+">")]
+# def extract_tag(txt,tagname):
+#     return txt[txt.find("<"+tagname+">")+len(tagname)+2:txt.find("</"+tagname+">")]
 
-def get_record(extract):
-    id = extract_tag(extract,"id")
-    updated = extract_tag(extract,"updated")
-    published = extract_tag(extract,"published")
-    title = extract_tag(extract,"title").replace("\n ","").strip()
-    summary = extract_tag(extract,"summary").replace("\n","").strip()
-    authors = []
-    while extract.find("<author>")!=-1:
-        author = extract_tag(extract,"name")
-        extract = extract[extract.find("</author>")+9:]
-        authors.append(author)
-    pattern = '<link title="pdf" href="'
-    link_start = extract.find('<link title="pdf" href="')
-    link = extract[link_start+len(pattern):extract.find("rel=",link_start)-2]
-    return [id, updated, published, title, authors, link, summary]
+# def get_record(extract):
+#     id = extract_tag(extract,"id")
+#     updated = extract_tag(extract,"updated")
+#     published = extract_tag(extract,"published")
+#     title = extract_tag(extract,"title").replace("\n ","").strip()
+#     summary = extract_tag(extract,"summary").replace("\n","").strip()
+#     authors = []
+#     while extract.find("<author>")!=-1:
+#         author = extract_tag(extract,"name")
+#         extract = extract[extract.find("</author>")+9:]
+#         authors.append(author)
+#     pattern = '<link title="pdf" href="'
+#     link_start = extract.find('<link title="pdf" href="')
+#     link = extract[link_start+len(pattern):extract.find("rel=",link_start)-2]
+#     return [id, updated, published, title, authors, link, summary]
 
-def crawl_exact_paper(title,author,max_results=3):
-    authors = authors_list_to_str(author)
-    records = []
-    url = 'http://export.arxiv.org/api/query?search_query=ti:{title}+AND+au:{author}&max_results={max_results}'.format(title=title,author=authors,max_results=max_results)
-    url = url.replace(" ","%20")
-    try:
-        arxiv_page = urllib.request.urlopen(url,timeout=100).read()
-        xml = str(arxiv_page,encoding="utf-8") 
-        while xml.find("<entry>") != -1:
-            extract = xml[xml.find("<entry>")+7:xml.find("</entry>")]
-            xml = xml[xml.find("</entry>")+8:]
-            extract = get_record(extract)
-            topic = choose_topic(extract[6])
-            records.append([topic,*extract])
-        return records
-    except Exception as e:
-        return "Error: "+str(e)
+# def crawl_exact_paper(title,author,max_results=3):
+#     authors = authors_list_to_str(author)
+#     records = []
+#     url = 'http://export.arxiv.org/api/query?search_query=ti:{title}+AND+au:{author}&max_results={max_results}'.format(title=title,author=authors,max_results=max_results)
+#     url = url.replace(" ","%20")
+#     try:
+#         arxiv_page = urllib.request.urlopen(url,timeout=100).read()
+#         xml = str(arxiv_page,encoding="utf-8") 
+#         while xml.find("<entry>") != -1:
+#             extract = xml[xml.find("<entry>")+7:xml.find("</entry>")]
+#             xml = xml[xml.find("</entry>")+8:]
+#             extract = get_record(extract)
+#             topic = choose_topic(extract[6])
+#             records.append([topic,*extract])
+#         return records
+#     except Exception as e:
+#         return "Error: "+str(e)
 
-def crawl_arxiv(keyword_list, max_results=100):
-    baseurl = 'http://export.arxiv.org/api/query?search_query='
-    records = []
-    for i,keyword in enumerate(keyword_list):
-        if i ==0:
-            url = baseurl + 'all:' + keyword
-        else:
-            url = url + '+OR+' + 'all:' + keyword
-    url = url+ '&max_results=' + str(max_results)
-    url = url.replace(' ', '%20')
-    try:
-        arxiv_page = urllib.request.urlopen(url,timeout=100).read()
-        xml = str(arxiv_page,encoding="utf-8") 
-        while xml.find("<entry>") != -1:
-            extract = xml[xml.find("<entry>")+7:xml.find("</entry>")]
-            xml = xml[xml.find("</entry>")+8:]
-            extract = get_record(extract)
-            topic = choose_topic(extract[6])
-            records.append([topic,*extract])
-        return records
-    except Exception as e:
-        return "Error: "+str(e)
+# def crawl_arxiv(keyword_list, max_results=100):
+#     baseurl = 'http://export.arxiv.org/api/query?search_query='
+#     records = []
+#     for i,keyword in enumerate(keyword_list):
+#         if i ==0:
+#             url = baseurl + 'all:' + keyword
+#         else:
+#             url = url + '+OR+' + 'all:' + keyword
+#     url = url+ '&max_results=' + str(max_results)
+#     url = url.replace(' ', '%20')
+#     try:
+#         arxiv_page = urllib.request.urlopen(url,timeout=100).read()
+#         xml = str(arxiv_page,encoding="utf-8") 
+#         while xml.find("<entry>") != -1:
+#             extract = xml[xml.find("<entry>")+7:xml.find("</entry>")]
+#             xml = xml[xml.find("</entry>")+8:]
+#             extract = get_record(extract)
+#             topic = choose_topic(extract[6])
+#             records.append([topic,*extract])
+#         return records
+#     except Exception as e:
+#         return "Error: "+str(e)
 
-class ArxivSQL:
-    def __init__(self, table="arxivsql", name="db.sqlite3"):
-        self.con = sqlite3.connect(name)
-        self.cur = self.con.cursor()
-        self.table = table
+# class ArxivSQL:
+#     def __init__(self, table="arxivsql", name="db.sqlite3"):
+#         self.con = sqlite3.connect(name)
+#         self.cur = self.con.cursor()
+#         self.table = table
     
-    def query(self, title="", author=[]):
-        if len(title)>0:
-            query_title = 'title like "%{}%"'.format(title)
-        else:
-            query_title = "True"
-        if len(author)>0:
-            query_author = 'authors like '
-            for auth in author:
-                query_author += "'%{}%' or ".format(auth)
-            query_author = query_author[:-4]
-        else:
-            query_author = "True"
-        query = "select * from {} where {} and {}".format(self.table,query_title,query_author)
-        result = self.cur.execute(query)
-        return result.fetchall()
+#     def query(self, title="", author=[]):
+#         if len(title)>0:
+#             query_title = 'title like "%{}%"'.format(title)
+#         else:
+#             query_title = "True"
+#         if len(author)>0:
+#             query_author = 'authors like '
+#             for auth in author:
+#                 query_author += "'%{}%' or ".format(auth)
+#             query_author = query_author[:-4]
+#         else:
+#             query_author = "True"
+#         query = "select * from {} where {} and {}".format(self.table,query_title,query_author)
+#         result = self.cur.execute(query)
+#         return result.fetchall()
 
-    def query_id(self, ids=[]):
-        try:
-            if len(ids) == 0:
-                return None
-            query = "select * from {} where id in (".format(self.table)
-            for id in ids:
-                query+="'"+id+"',"
-            query = query[:-1] + ")"
-            result = self.cur.execute(query)
-            return result.fetchall()
-        except Exception as e:
-            print(e)
-            print("Error query: ",query)
+#     def query_id(self, ids=[]):
+#         try:
+#             if len(ids) == 0:
+#                 return None
+#             query = "select * from {} where id in (".format(self.table)
+#             for id in ids:
+#                 query+="'"+id+"',"
+#             query = query[:-1] + ")"
+#             result = self.cur.execute(query)
+#             return result.fetchall()
+#         except Exception as e:
+#             print(e)
+#             print("Error query: ",query)
     
-    def add(self, crawl_records):
-        """
-        Add crawl_records (list) obtained from arxiv_crawlers
-        A record is a list of 8 columns: 
-        [topic, id, updated, published, title, author, link, summary]
-        Return the final length of the database table
-        """
-        results = ""
-        for record in crawl_records:
-            try:
-                query = """insert into arxivsql values("{}","{}","{}","{}","{}","{}","{}")""".format(
-                    record[1][21:],
-                    record[0],
-                    record[4].replace('"',"'"),
-                    authors_list_to_str(record[5]),
-                    record[2][:10],
-                    record[3][:10],
-                    record[6]
-                )
-                self.cur.execute(query)
-                self.con.commit()
-            except Exception as e:
-                result+=str(e)
-                result+="\n" + query + "\n"
-            finally:
-                return results
+#     def add(self, crawl_records):
+#         """
+#         Add crawl_records (list) obtained from arxiv_crawlers
+#         A record is a list of 8 columns: 
+#         [topic, id, updated, published, title, author, link, summary]
+#         Return the final length of the database table
+#         """
+#         results = ""
+#         for record in crawl_records:
+#             try:
+#                 query = """insert into arxivsql values("{}","{}","{}","{}","{}","{}","{}")""".format(
+#                     record[1][21:],
+#                     record[0],
+#                     record[4].replace('"',"'"),
+#                     authors_list_to_str(record[5]),
+#                     record[2][:10],
+#                     record[3][:10],
+#                     record[6]
+#                 )
+#                 self.cur.execute(query)
+#                 self.con.commit()
+#             except Exception as e:
+#                 result+=str(e)
+#                 result+="\n" + query + "\n"
+#             finally:
+#                 return results
             
-# instance of ArxivSQL
-sqldb = ArxivSQL()
+# # instance of ArxivSQL
+# sqldb = ArxivSQL()
 
-class ArxivChroma:
-    """
-    Create an interface to arxivdb, which only support query and addition.
-    This interface do not support edition and deletion procedures. 
-    """
-    def __init__(self, table="arxiv_records", name="arxivdb/"):
-        self.client = chromadb.PersistentClient(name)
-        self.model = embedding_model
-        self.collection = self.client.get_or_create_collection(table,
-                                                               embedding_function=JinaAIEmbeddingFunction(
-                                                                   model = self.model
-                                                               ))
+# class ArxivChroma:
+#     """
+#     Create an interface to arxivdb, which only support query and addition.
+#     This interface do not support edition and deletion procedures. 
+#     """
+#     def __init__(self, table="arxiv_records", name="arxivdb/"):
+#         self.client = chromadb.PersistentClient(name)
+#         self.model = embedding_model
+#         self.collection = self.client.get_or_create_collection(table,
+#                                                                embedding_function=JinaAIEmbeddingFunction(
+#                                                                    model = self.model
+#                                                                ))
     
-    def query_relevant(self, keywords, query_texts, n_results=3):
-        """
-        Perform a query using a list of keywords (str),
-        or using a relavant string
-        """
-        contains = []
-        for keyword in keywords:
-            contains.append({"$contains":keyword.lower()})
-        return self.collection.query(
-            query_texts=query_texts,
-            where_document={
-                "$or":contains
-            },
-            n_results=n_results,
-        )
+#     def query_relevant(self, keywords, query_texts, n_results=3):
+#         """
+#         Perform a query using a list of keywords (str),
+#         or using a relavant string
+#         """
+#         contains = []
+#         for keyword in keywords:
+#             contains.append({"$contains":keyword.lower()})
+#         return self.collection.query(
+#             query_texts=query_texts,
+#             where_document={
+#                 "$or":contains
+#             },
+#             n_results=n_results,
+#         )
     
-    def query_exact(self, id):
-        ids = ["{}_{}".format(id,j) for j in range(0,10)]
-        return self.collection.get(ids=ids)
+#     def query_exact(self, id):
+#         ids = ["{}_{}".format(id,j) for j in range(0,10)]
+#         return self.collection.get(ids=ids)
 
-    def add(self, crawl_records):
-        """
-        Add crawl_records (list) obtained from arxiv_crawlers
-        A record is a list of 8 columns: 
-        [topic, id, updated, published, title, author, link, summary]
-        Return the final length of the database table
-        """
-        for record in crawl_records:
-                embed_text = """
-                Topic: {},
-                Title: {},
-                Summary: {}
-            """.format(record[0],record[4],record[7])
-                chunks = chunk_texts(embed_text)
-                ids = [record[1][21:]+"_"+str(j) for j in range(len(chunks))]
-                paper_ids = [{"paper_id":record[1][21:]} for _ in range(len(chunks))]
-                self.collection.add(
-                    documents = chunks,
-                    metadatas=paper_ids,
-                    ids = ids
-                )
-        return self.collection.count()
+#     def add(self, crawl_records):
+#         """
+#         Add crawl_records (list) obtained from arxiv_crawlers
+#         A record is a list of 8 columns: 
+#         [topic, id, updated, published, title, author, link, summary]
+#         Return the final length of the database table
+#         """
+#         for record in crawl_records:
+#                 embed_text = """
+#                 Topic: {},
+#                 Title: {},
+#                 Summary: {}
+#             """.format(record[0],record[4],record[7])
+#                 chunks = chunk_texts(embed_text)
+#                 ids = [record[1][21:]+"_"+str(j) for j in range(len(chunks))]
+#                 paper_ids = [{"paper_id":record[1][21:]} for _ in range(len(chunks))]
+#                 self.collection.add(
+#                     documents = chunks,
+#                     metadatas=paper_ids,
+#                     ids = ids
+#                 )
+#         return self.collection.count()
 
-# instance of ArxivChroma
-db = ArxivChroma()
+# # instance of ArxivChroma
+# db = ArxivChroma()
 

chat/arxiv_bot/arxiv_bot_utils2.py

@@ -0,0 +1,297 @@
+import chromadb
+from chromadb import Documents, EmbeddingFunction, Embeddings
+from transformers import AutoModel
+import json
+from numpy.linalg import norm
+import sqlite3
+import urllib
+from django.conf import settings
+import Levenshtein
+
+# this module act as a singleton class
+
+class JinaAIEmbeddingFunction(EmbeddingFunction):
+    def __init__(self, model):
+        super().__init__()
+        self.model = model
+
+    def __call__(self, input: Documents) -> Embeddings:
+        embeddings = self.model.encode(input)
+        return embeddings.tolist()
+
+# instance of embedding_model
+embedding_model = AutoModel.from_pretrained('jinaai/jina-embeddings-v2-base-en',
+                                                trust_remote_code=True,
+                                                cache_dir='models')
+
+# instance of JinaAIEmbeddingFunction
+ef = JinaAIEmbeddingFunction(embedding_model)
+
+# list of topics
+topic_descriptions = json.load(open("topic_descriptions.txt")) 
+topics = list(dict.keys(topic_descriptions))
+embeddings = [embedding_model.encode(topic_descriptions[key]) for key in topic_descriptions]
+cos_sim = lambda a,b: (a @ b.T) / (norm(a)*norm(b))
+
+def lev_sim(a,b): return Levenshtein.distance(a,b)
+
+def choose_topic(summary):
+    embed = embedding_model.encode(summary)
+    topic = ""
+    max_sim = 0.
+    for i,key in enumerate(topics):
+        sim = cos_sim(embed,embeddings[i])
+        if sim > max_sim:
+            topic = key
+            max_sim = sim
+    return topic
+
+def authors_list_to_str(authors):
+   """input a list of authors, return a string represent authors"""
+   text = ""
+   for author in authors:
+      text+=author+", "
+   return text[:-3]
+
+def authors_str_to_list(string):
+    """input a string of authors, return a list of authors"""
+    authors = []
+    list_auth = string.split("and")
+    for author in list_auth:
+        if author != "et al.":
+            authors.append(author.strip())
+    return authors
+
+def chunk_texts(text, max_char=400):
+  """
+  Chunk a long text into several chunks, with each chunk about 300-400 characters long,
+  but make sure no word is cut in half.
+  Args:
+      text: The long text to be chunked.
+      max_char: The maximum number of characters per chunk (default: 400).
+  Returns:
+      A list of chunks.
+  """
+  chunks = []
+  current_chunk = ""
+  words = text.split()
+  for word in words:
+    if len(current_chunk) + len(word) + 1 >= max_char:
+        chunks.append(current_chunk)
+        current_chunk = " "
+    else:
+      current_chunk += " " + word
+  chunks.append(current_chunk.strip())
+  return chunks
+
+def trimming(txt):
+    start = txt.find("{")
+    end = txt.rfind("}")
+    return txt[start:end+1].replace("\n"," ")
+
+# crawl data
+
+def extract_tag(txt,tagname):
+    return txt[txt.find("<"+tagname+">")+len(tagname)+2:txt.find("</"+tagname+">")]
+
+def get_record(extract):
+    id = extract_tag(extract,"id")
+    updated = extract_tag(extract,"updated")
+    published = extract_tag(extract,"published")
+    title = extract_tag(extract,"title").replace("\n ","").strip()
+    summary = extract_tag(extract,"summary").replace("\n","").strip()
+    authors = []
+    while extract.find("<author>")!=-1:
+        author = extract_tag(extract,"name")
+        extract = extract[extract.find("</author>")+9:]
+        authors.append(author)
+    pattern = '<link title="pdf" href="'
+    link_start = extract.find('<link title="pdf" href="')
+    link = extract[link_start+len(pattern):extract.find("rel=",link_start)-2]
+    return [id, updated, published, title, authors, link, summary]
+
+def crawl_exact_paper(title,author,max_results=3):
+    authors = authors_list_to_str(author)
+    records = []
+    url = 'http://export.arxiv.org/api/query?search_query=ti:{title}+AND+au:{author}&max_results={max_results}'.format(title=title,author=authors,max_results=max_results)
+    url = url.replace(" ","%20")
+    try:
+        arxiv_page = urllib.request.urlopen(url,timeout=100).read()
+        xml = str(arxiv_page,encoding="utf-8") 
+        while xml.find("<entry>") != -1:
+            extract = xml[xml.find("<entry>")+7:xml.find("</entry>")]
+            xml = xml[xml.find("</entry>")+8:]
+            extract = get_record(extract)
+            topic = choose_topic(extract[6])
+            records.append([topic,*extract])
+        return records
+    except Exception as e:
+        return "Error: "+str(e)
+
+def crawl_arxiv(keyword_list, max_results=100):
+    baseurl = 'http://export.arxiv.org/api/query?search_query='
+    records = []
+    for i,keyword in enumerate(keyword_list):
+        if i ==0:
+            url = baseurl + 'all:' + keyword
+        else:
+            url = url + '+OR+' + 'all:' + keyword
+    url = url+ '&max_results=' + str(max_results)
+    url = url.replace(' ', '%20')
+    try:
+        arxiv_page = urllib.request.urlopen(url,timeout=100).read()
+        xml = str(arxiv_page,encoding="utf-8") 
+        while xml.find("<entry>") != -1:
+            extract = xml[xml.find("<entry>")+7:xml.find("</entry>")]
+            xml = xml[xml.find("</entry>")+8:]
+            extract = get_record(extract)
+            topic = choose_topic(extract[6])
+            records.append([topic,*extract])
+        return records
+    except Exception as e:
+        return "Error: "+str(e)
+
+# This class act as a module
+class ArxivChroma:
+    """
+    Create an interface to arxivdb, which only support query and addition.
+    This interface do not support edition and deletion procedures. 
+    """
+    client = None
+    model = None
+    collection = None
+    
+    @staticmethod
+    def connect(table="arxiv_records", name="arxivdb/"):
+        ArxivChroma.client = chromadb.PersistentClient(name)
+        ArxivChroma.model = embedding_model
+        ArxivChroma.collection = ArxivChroma.client.get_or_create_collection(table,
+                                                                            embedding_function=JinaAIEmbeddingFunction(
+                                                                            model = ArxivChroma.model
+                                                                            ))
+
+    @staticmethod
+    def query_relevant(keywords, query_texts, n_results=3):
+        """
+        Perform a query using a list of keywords (str),
+        or using a relavant string
+        """
+        contains = []
+        for keyword in keywords:
+            contains.append({"$contains":keyword.lower()})
+        return ArxivChroma.collection.query(
+            query_texts=query_texts,
+            where_document={
+                "$or":contains
+            },
+            n_results=n_results,
+        )
+
+    @staticmethod
+    def query_exact(id):
+        ids = ["{}_{}".format(id,j) for j in range(0,10)]
+        return ArxivChroma.collection.get(ids=ids)
+
+    @staticmethod
+    def add(crawl_records):
+        """
+        Add crawl_records (list) obtained from arxiv_crawlers
+        A record is a list of 8 columns: 
+        [topic, id, updated, published, title, author, link, summary]
+        Return the final length of the database table
+        """
+        for record in crawl_records:
+                embed_text = """
+                Topic: {},
+                Title: {},
+                Summary: {}
+            """.format(record[0],record[4],record[7])
+                chunks = chunk_texts(embed_text)
+                ids = [record[1][21:]+"_"+str(j) for j in range(len(chunks))]
+                paper_ids = [{"paper_id":record[1][21:]} for _ in range(len(chunks))]
+                ArxivChroma.collection.add(
+                    documents = chunks,
+                    metadatas=paper_ids,
+                    ids = ids
+                )
+        return ArxivChroma.collection.count()
+
+    @staticmethod
+    def close_connection():
+        pass
+
+# This class act as a module
+class ArxivSQL:
+    table = "arxivsql"
+    con = None
+    cur = None
+
+    @staticmethod
+    def connect(name="db.sqlite3"):
+        ArxivSQL.con = sqlite3.connect(name, check_same_thread=False)
+        ArxivSQL.cur = ArxivSQL.con.cursor()
+
+    @staticmethod
+    def query(title="", author=[], threshold = 15):
+        if len(author)>0:
+            query_author= " OR ".join([f"author LIKE '%{a}%'" for a in author])
+        else:
+            query_author= "True"
+        # Execute the query
+        query = f"select * from {ArxivSQL.table} where {query_author}"
+        results = ArxivSQL.cursor.execute(query).fetchall()
+        if len(title) == 0:
+            return results
+        else:
+            sim_score = {}
+            for row in results:
+                row_title = row[2]
+                row_id = row[0]
+                score = lev_sim(title, row_title)
+                if score < threshold:
+                    sim_score[row_id] = score
+            sorted_results = sorted(sim_score.items(), key=lambda x: x[1])
+            return ArxivSQL.query_id(sorted_results)
+
+    @staticmethod     
+    def query_id(ids=[]):
+        try:
+            if len(ids) == 0:
+                return None
+            query = "select * from {} where id in (".format(ArxivSQL.table)
+            for id in ids:
+                query+="'"+id+"',"
+            query = query[:-1] + ")"
+            result = ArxivSQL.cur.execute(query)
+            return result.fetchall()
+        except Exception as e:
+            print(e)
+            print("Error query: ",query)
+
+    @staticmethod
+    def add(crawl_records):
+        """
+        Add crawl_records (list) obtained from arxiv_crawlers
+        A record is a list of 8 columns: 
+        [topic, id, updated, published, title, author, link, summary]
+        Return the final length of the database table
+        """
+        results = ""
+        for record in crawl_records:
+            try:
+                query = """insert into arxivsql values("{}","{}","{}","{}","{}","{}","{}")""".format(
+                    record[1][21:],
+                    record[0],
+                    record[4].replace('"',"'"),
+                    authors_list_to_str(record[5]),
+                    record[2][:10],
+                    record[3][:10],
+                    record[6]
+                )
+                ArxivSQL.cur.execute(query)
+                ArxivSQL.con.commit()
+            except Exception as e:
+                results+=str(e)
+                results+="\n" + query + "\n"
+            finally:
+                return results

chat/arxiv_bot/prebuild.ipynb

@@ -1,354 +1,354 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "d:\\Program\\Anaconda\\envs\\python_project\\lib\\site-packages\\tqdm\\auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
-      "  from .autonotebook import tqdm as notebook_tqdm\n",
-      "d:\\Program\\Anaconda\\envs\\python_project\\lib\\site-packages\\huggingface_hub\\file_download.py:1132: FutureWarning: `resume_download` is deprecated and will be removed in version 1.0.0. Downloads always resume when possible. If you want to force a new download, use `force_download=True`.\n",
-      "  warnings.warn(\n",
-      "d:\\Program\\Anaconda\\envs\\python_project\\lib\\site-packages\\huggingface_hub\\file_download.py:1132: FutureWarning: `resume_download` is deprecated and will be removed in version 1.0.0. Downloads always resume when possible. If you want to force a new download, use `force_download=True`.\n",
-      "  warnings.warn(\n"
-     ]
-    }
-   ],
-   "source": [
-    "import google.generativeai as genai\n",
-    "import arxiv_bot_utils as utils\n",
-    "import os\n",
-    "from getpass import getpass\n",
-    "import json\n",
-    "#chỉ là import một cách bình thường\n",
-    "#nội dung là "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "models/gemini-1.0-pro\n",
-      "models/gemini-1.0-pro-001\n",
-      "models/gemini-1.0-pro-latest\n",
-      "models/gemini-1.0-pro-vision-latest\n",
-      "models/gemini-1.5-pro-latest\n",
-      "models/gemini-pro\n",
-      "models/gemini-pro-vision\n"
-     ]
-    }
-   ],
-   "source": [
-    "os.environ['GEMINI_API_KEY'] = getpass(\"Input your API key: \")\n",
-    "# gán biến môi trường luôn\n",
-    "gemini_api_key = os.getenv(\"GEMINI_API_KEY\") # string trong môi trường\n",
-    "if not gemini_api_key:\n",
-    "    raise ValueError(\n",
-    "            \"Gemini API Key not provided. Please provide GEMINI_API_KEY as an environment variable\"\n",
-    "        )\n",
-    "genai.configure(api_key=gemini_api_key)\n",
-    "for m in genai.list_models():\n",
-    "  if 'generateContent' in m.supported_generation_methods:\n",
-    "    print(m.name)\n",
-    "    #models nằm trên máy chủ\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "config = genai.GenerationConfig(max_output_tokens=2048,\n",
-    "                                temperature=0.7)\n",
-    "safety_settings = [\n",
-    "    {\n",
-    "        \"category\": \"HARM_CATEGORY_DANGEROUS\",\n",
-    "        \"threshold\": \"BLOCK_NONE\",\n",
-    "    },\n",
-    "    {\n",
-    "        \"category\": \"HARM_CATEGORY_HARASSMENT\",\n",
-    "        \"threshold\": \"BLOCK_NONE\",\n",
-    "    },\n",
-    "    {\n",
-    "        \"category\": \"HARM_CATEGORY_HATE_SPEECH\",\n",
-    "        \"threshold\": \"BLOCK_NONE\",\n",
-    "    },\n",
-    "    {\n",
-    "        \"category\": \"HARM_CATEGORY_SEXUALLY_EXPLICIT\",\n",
-    "        \"threshold\": \"BLOCK_NONE\",\n",
-    "    },\n",
-    "    {\n",
-    "        \"category\": \"HARM_CATEGORY_DANGEROUS_CONTENT\",\n",
-    "        \"threshold\": \"BLOCK_NONE\",\n",
-    "    },\n",
-    "]\n",
-    "model = genai.GenerativeModel(\"gemini-pro\",\n",
-    "                              generation_config=config,\n",
-    "                              safety_settings=safety_settings)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def extract_keyword_prompt(query):\n",
-    "    \"\"\"A prompt that return a JSON block as arguments for querying database\"\"\"\n",
-    "\n",
-    "    prompt = (\n",
-    "        \"\"\"[INST] SYSTEM: You are an assistant that choose only one action below based on guest question.\n",
-    "   1. If the guest question is asking for a single specific document or article with explicit title, you need to respond the information in JSON format with 2 keys \"title\", \"author\" if found any above. The authors are separated with the word 'and'. \n",
-    "   2. If the guest question is asking for relevant informations about a topic, you need to respond the information in JSON format with 2 keys \"keywords\", \"description\", include a list of keywords represent the main academic topic, \\\n",
-    "     and a description about the main topic. You may paraphrase the keywords to add more. \\\n",
-    "   3. If the guest is not asking for any informations or documents, you need to respond with a polite answer in JSON format with 1 key \"answer\".\n",
-    "   QUESTION: '{query}'\n",
-    "   [/INST]\n",
-    "   ANSWER: \n",
-    "   \"\"\"\n",
-    "    ).format(query=query)\n",
-    "\n",
-    "    return prompt\n",
-    "\n",
-    "def make_answer_prompt(input, contexts):\n",
-    "    \"\"\"A prompt that return the final answer, based on the queried context\"\"\"\n",
-    "\n",
-    "    prompt = (\n",
-    "        \"\"\"[INST] You are a library assistant that help to search articles and documents based on user's question.\n",
-    "  From guest's question, you have found some records and documents that may help. Now you need to answer the guest with the information found.\n",
-    "  If no information found in the database, you may generate some other recommendation related to user's question using your own knowledge. Each article or paper must have a link to the pdf download page.\n",
-    "  You should answer in a conversational form politely.\n",
-    "  QUESTION: '{input}'\n",
-    "  INFORMATION: '{contexts}'\n",
-    "  [/INST]\n",
-    "  ANSWER:\n",
-    "  \"\"\"\n",
-    "    ).format(input=input, contexts=contexts)\n",
-    "\n",
-    "    return prompt"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def response(args):\n",
-    "    \"\"\"Create response context, based on input arguments\"\"\"\n",
-    "    keys = list(dict.keys(args))\n",
-    "    if \"answer\" in keys:\n",
-    "        return args['answer'], None  # trả lời trực tiếp\n",
-    "     \n",
-    "    if \"keywords\" in keys:\n",
-    "        # perform query\n",
-    "        query_texts = args[\"description\"]\n",
-    "        keywords = args[\"keywords\"]\n",
-    "        results = utils.db.query_relevant(keywords=keywords, query_texts=query_texts)\n",
-    "        # print(results)\n",
-    "        ids = results['metadatas'][0]\n",
-    "        if len(ids) == 0:\n",
-    "            # go crawl some\n",
-    "            new_records = utils.crawl_arxiv(keyword_list=keywords, max_results=10)\n",
-    "            print(\"Got new records: \",len(new_records))\n",
-    "            if type(new_records) == str:\n",
-    "                return \"Error occured, information not found\", new_records\n",
-    "            utils.db.add(new_records)\n",
-    "            utils.sqldb.add(new_records)\n",
-    "            results = utils.db.query_relevant(keywords=keywords, query_texts=query_texts)\n",
-    "            ids = results['metadatas'][0]\n",
-    "            print(\"Re-queried on chromadb, results: \",ids)\n",
-    "        paper_id = [id['paper_id'] for id in ids]\n",
-    "        paper_info = utils.sqldb.query_id(paper_id)\n",
-    "        print(paper_info)\n",
-    "        records = [] # get title (2), author (3), link (6)\n",
-    "        result_string = \"\"\n",
-    "        if paper_info:\n",
-    "            for i in range(len(paper_info)):\n",
-    "                result_string += \"Title: {}, Author: {}, Link: {}\".format(paper_info[i][2],paper_info[i][3],paper_info[i][6])\n",
-    "                records.append([paper_info[i][2],paper_info[i][3],paper_info[i][6]])\n",
-    "                return result_string, records\n",
-    "        else:\n",
-    "            return \"Information not found\", \"Information not found\"\n",
-    "        # invoke llm and return result\n",
-    "\n",
-    "    if \"title\" in keys:\n",
-    "        title = args['title']\n",
-    "        authors = utils.authors_str_to_list(args['author'])\n",
-    "        paper_info = utils.sqldb.query(title = title,author = authors)\n",
-    "        # if query not found then go crawl brh\n",
-    "        # print(paper_info)\n",
-    "\n",
-    "        if len(paper_info) == 0:\n",
-    "            new_records = utils.crawl_exact_paper(title=title,author=authors)\n",
-    "            print(\"Got new records: \",len(new_records))\n",
-    "            if type(new_records) == str:\n",
-    "                # print(new_records)\n",
-    "                return \"Error occured, information not found\", \"Information not found\"\n",
-    "            utils.db.add(new_records)\n",
-    "            utils.sqldb.add(new_records)\n",
-    "            paper_info = utils.sqldb.query(title = title,author = authors)\n",
-    "            print(\"Re-queried on chromadb, results: \",paper_info)\n",
-    "        # -------------------------------------\n",
-    "        records = [] # get title (2), author (3), link (6)\n",
-    "        result_string = \"\"\n",
-    "        for i in range(len(paper_info)):\n",
-    "            result_string += \"Title: {}, Author: {}, Link: {}\".format(paper_info[i][2],paper_info[i][3],paper_info[i][6])\n",
-    "            records.append([paper_info[i][2],paper_info[i][3],paper_info[i][6]])\n",
-    "        # process results:\n",
-    "        if len(result_string) == 0:\n",
-    "            return \"Information not found\", \"Information not found\"\n",
-    "        return result_string, records\n",
-    "        # invoke llm and return result"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def full_chain_single_question(input_prompt):\n",
-    "    try:\n",
-    "        first_prompt = extract_keyword_prompt(input_prompt)\n",
-    "        temp_answer = model.generate_content(first_prompt).text\n",
-    "\n",
-    "        args = json.loads(utils.trimming(temp_answer))\n",
-    "        contexts, results = response(args)\n",
-    "        if not results:\n",
-    "            print(contexts)\n",
-    "        else:\n",
-    "            output_prompt = make_answer_prompt(input_prompt,contexts)\n",
-    "            answer = model.generate_content(output_prompt).text\n",
-    "        return temp_answer, answer\n",
-    "    except Exception as e:\n",
-    "        print(e)\n",
-    "        return temp_answer, \"Error occured: \" + str(e)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 27,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[('1903.04824v1', 'computer science', 'Proceedings of the Fifth International Conference on Cloud and Robotics (ICCR2018)', ' Huaxi,  Zhang, Jacques Malenfan', '2019-03-12', '2019-03-12', 'http://arxiv.org/pdf/1903.04824v1'), ('1709.07597v1', 'economics', 'Inverse Reinforcement Learning with Conditional Choice Probabilities', 'Mohit Sharma, Kris M. Kitani, Joachim Groege', '2017-09-22', '2017-09-22', 'http://arxiv.org/pdf/1709.07597v1')]\n",
-      "Sure, here are some key papers on model predictive control for nonlinear systems:\n",
-      "\n",
-      "* **Nonlinear Model Predictive Control: A Survey** by Garcia, P.D., Prett, D.M., and Morari, M. (1989)\n",
-      "* **Model Predictive Control for Nonlinear Systems** by Camacho, E.F. and Bordons, C. (1999)\n",
-      "* **Nonlinear Model Predictive Control** by Rawlings, J.B. and Mayne, D.Q. (2009)\n",
-      "\n",
-      "As for recent reviews on the application of control theory to robotics, here are a few:\n",
-      "\n",
-      "* **Control of Robot Manipulators** by Spong, M.W., Hutchinson, S., and Vidyasagar, M. (2006)\n",
-      "* **Robotics: Modelling, Planning and Control** by Siciliano, B., Sciavicco, L., Villani, L., and Oriolo, G. (2010)\n",
-      "* **Control of Robot Arms** by Featherstone, R. (2014)\n",
-      "\n",
-      "I hope this information is helpful. Please let me know if you have any other questions.\n"
-     ]
-    }
-   ],
-   "source": [
-    "# test response, second step\n",
-    "input_prompt = \"Can you suggest some key papers on model predictive control for nonlinear systems, and are there any recent reviews on the application of control theory to robotics?\"\n",
-    "args = \"{\\n \\\"keywords\\\": [\\\"Model predictive control\\\", \\\"Nonlinear systems\\\", \\\"Robotics\\\", \\\"Control theory\\\"],\\n \\\"description\\\": \\\"Model predictive control (MPC) is a control algorithm that uses a model of the system to predict future behavior and optimize the control inputs. MPC is particularly well-suited for nonlinear systems, as it can handle the complex dynamics of these systems. In recent years, MPC has been increasingly applied to robotics, as it can improve the performance and safety of robotic systems. Control theory is a branch of mathematics that deals with the analysis and design of control systems. Control theory has been applied to a wide range of problems in robotics, including motion planning, trajectory tracking, and force control.\\\"\\n}\"\n",
-    "args = json.loads(args)\n",
-    "contexts, results = response(args)\n",
-    "if not results:\n",
-    "  # direct answer\n",
-    "  print(contexts)\n",
-    "else:\n",
-    "  output_prompt = make_answer_prompt(input_prompt,contexts)\n",
-    "  answer = model.generate_content(output_prompt).text\n",
-    "  print(answer)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "{'desired': 'Natural Language Processing (Computer Science)', 'question': 'What are some recent papers on deep learning architectures for text classification, and can you recommend any surveys or reviews on the topic?'}\n",
-      "0\n",
-      "[('1808.08121v1', 'computer science', 'An Improvement of Data Classification Using Random Multimodel Deep Learning (RMDL)', 'Mojtaba Heidarysafa, Kamran Kowsari, Donald E. Brown, Kiana Jafari Meimandi, Laura E. Barne', '2018-08-23', '2018-08-23', 'http://arxiv.org/pdf/1808.08121v1'), ('1904.08067v5', 'computer science', 'Text Classification Algorithms: A Survey', 'Kamran Kowsari, Kiana Jafari Meimandi, Mojtaba Heidarysafa, Sanjana Mendu, Laura E. Barnes, Donald E. Brow', '2020-05-20', '2019-04-17', 'http://arxiv.org/pdf/1904.08067v5'), ('2202.09144v1', 'computer science', 'Modelling the semantics of text in complex document layouts using graph transformer networks', 'Thomas Roland Barillot, Jacob Saks, Polena Lilyanova, Edward Torgas, Yachen Hu, Yuanqing Liu, Varun Balupuri, Paul Gaskel', '2022-02-18', '2022-02-18', 'http://arxiv.org/pdf/2202.09144v1')]\n",
-      "1\n",
-      "[('1601.04187v1', 'computer science', 'Conversion of Artificial Recurrent Neural Networks to Spiking Neural Networks for Low-power Neuromorphic Hardware', 'Peter U. Diehl, Guido Zarrella, Andrew Cassidy, Bruno U. Pedroni, Emre Neftc', '2016-01-16', '2016-01-16', 'http://arxiv.org/pdf/1601.04187v1'), ('1801.01093v3', 'economics', 'Comparing the Forecasting Performances of Linear Models for Electricity Prices with High RES Penetration', 'Angelica Gianfreda, Francesco Ravazzolo, Luca Rossin', '2019-11-12', '2018-01-03', 'http://arxiv.org/pdf/1801.01093v3'), ('2302.11093v1', 'electrical engineering and system science', 'Use Cases for Time-Frequency Image Representations and Deep Learning Techniques for Improved Signal Classification', 'Mehmet Parla', '2023-02-22', '2023-02-22', 'http://arxiv.org/pdf/2302.11093v1')]\n",
-      "2\n",
-      "[('1505.07907v4', 'economics', 'Linking Economic Complexity, Institutions and Income Inequality', 'D. Hartmann, M. R. Guevara, C. Jara-Figueroa, M. Aristaran, C. A. Hidalg', '2017-01-04', '2015-05-29', 'http://arxiv.org/pdf/1505.07907v4'), ('2107.06855v2', 'economics', 'Comparing Intellectual property policy in the Global North and South -- A one-size-fits-all policy for economic prosperity?', 'S Sidhartha Narayan, Malavika Ranjan, Madhumitha Raghurama', '2021-08-10', '2021-07-14', 'http://arxiv.org/pdf/2107.06855v2'), ('1910.11780v1', 'economics', 'Inequality in Turkey: Looking Beyond Growth', 'Bayram Cakir, Ipek Ergu', '2019-10-25', '2019-10-25', 'http://arxiv.org/pdf/1910.11780v1')]\n",
-      "3\n",
-      "[('1607.06583v2', 'computer science', \"Classification of Alzheimer's Disease Structural MRI Data by Deep Learning Convolutional Neural Networks\", 'Saman Sarraf, Ghassem Tofigh', '2017-05-19', '2016-07-22', 'http://arxiv.org/pdf/1607.06583v2'), ('2101.10265v1', 'computer science', 'Superiorities of Deep Extreme Learning Machines against Convolutional Neural Networks', 'Gokhan Altan, Yakup Kutl', '2021-01-21', '2021-01-21', 'http://arxiv.org/pdf/2101.10265v1'), ('2208.03143v1', 'computer science', 'Deep Learning and Health Informatics for Smart Monitoring and Diagnosis', 'Amin Gasm', '2022-08-05', '2022-08-05', 'http://arxiv.org/pdf/2208.03143v1')]\n",
-      "4\n",
-      "[('2302.06584v3', 'computer science', 'Thermodynamic AI and the fluctuation frontier', 'Patrick J. Coles, Collin Szczepanski, Denis Melanson, Kaelan Donatella, Antonio J. Martinez, Faris Sbah', '2023-06-13', '2023-02-09', 'http://arxiv.org/pdf/2302.06584v3'), ('2307.12298v1', 'computer science', 'Stabilization and Dissipative Information Transfer of a Superconducting Kerr-Cat Qubit', 'Ufuk Korkmaz, Deniz Türkpenç', '2023-07-23', '2023-07-23', 'http://arxiv.org/pdf/2307.12298v1'), ('2106.10421v1', 'computer science', 'QFCNN: Quantum Fourier Convolutional Neural Network', 'Feihong Shen, Jun Li', '2021-06-19', '2021-06-19', 'http://arxiv.org/pdf/2106.10421v1')]\n",
-      "5\n",
-      "[('2308.16539v2', 'computer science', 'On a Connection between Differential Games, Optimal Control, and Energy-based Models for Multi-Agent Interactions', 'Christopher Diehl, Tobias Klosek, Martin Krüger, Nils Murzyn, Torsten Bertra', '2023-10-16', '2023-08-31', 'http://arxiv.org/pdf/2308.16539v2'), ('2404.12474v1', 'computer science', 'Learning a Stable, Safe, Distributed Feedback Controller for a Heterogeneous Platoon of Vehicles', 'Michael H. Shaham, Taskin Padi', '2024-04-18', '2024-04-18', 'http://arxiv.org/pdf/2404.12474v1'), ('2008.13221v1', 'computer science', 'Human-in-the-Loop Methods for Data-Driven and Reinforcement Learning Systems', 'Vinicius G. Goeck', '2020-08-30', '2020-08-30', 'http://arxiv.org/pdf/2008.13221v1')]\n",
-      "6\n",
-      "[('1911.06206v3', 'economics', 'Bayesian state-space modeling for analyzing heterogeneous network effects of US monetary policy', 'Niko Hauzenberger, Michael Pfarrhofe', '2020-09-10', '2019-11-14', 'http://arxiv.org/pdf/1911.06206v3'), ('2302.14114v1', 'economics', 'Econometric assessment of the monetary policy shocks in Morocco: Evidence from a Bayesian Factor-Augmented VAR', 'Marouane Daou', '2023-02-27', '2023-02-27', 'http://arxiv.org/pdf/2302.14114v1'), ('2311.11858v1', 'economics', 'Theory coherent shrinkage of Time-Varying Parameters in VARs', 'Andrea Renzett', '2023-11-20', '2023-11-20', 'http://arxiv.org/pdf/2311.11858v1')]\n",
-      "7\n",
-      "[('2310.03365v2', 'computer science', 'Swin-Tempo: Temporal-Aware Lung Nodule Detection in CT Scans as Video Sequences Using Swin Transformer-Enhanced UNet', 'Hossein Jafari, Karim Faez, Hamidreza Amindava', '2023-10-14', '2023-10-05', 'http://arxiv.org/pdf/2310.03365v2'), ('1808.08531v1', 'computer science', 'DeepTracker: Visualizing the Training Process of Convolutional Neural Networks', 'Dongyu Liu, Weiwei Cui, Kai Jin, Yuxiao Guo, Huamin Q', '2018-08-26', '2018-08-26', 'http://arxiv.org/pdf/1808.08531v1'), ('2105.10448v1', 'computer science', 'Distinguishing artefacts: evaluating the saturation point of convolutional neural networks', 'Ric Real, James Gopsill, David Jones, Chris Snider, Ben Hick', '2021-05-21', '2021-05-21', 'http://arxiv.org/pdf/2105.10448v1')]\n",
-      "8\n",
-      "Got new records:  10\n",
-      "Re-queried on chromadb, results:  []\n",
-      "None\n",
-      "9\n",
-      "[('2403.07017v1', 'computer science', 'Mathematics of multi-agent learning systems at the interface of game theory and artificial intelligence', 'Long Wang, Feng Fu, Xingru Che', '2024-03-09', '2024-03-09', 'http://arxiv.org/pdf/2403.07017v1'), ('2210.02205v1', 'computer science', 'Game Theoretic Rating in N-player general-sum games with Equilibria', 'Luke Marris, Marc Lanctot, Ian Gemp, Shayegan Omidshafiei, Stephen McAleer, Jerome Connor, Karl Tuyls, Thore Graepe', '2022-10-05', '2022-10-05', 'http://arxiv.org/pdf/2210.02205v1'), ('2212.05357v3', 'economics', 'On Blockchain We Cooperate: An Evolutionary Game Perspective', 'Luyao Zhang, Xinyu Tia', '2023-01-19', '2022-12-10', 'http://arxiv.org/pdf/2212.05357v3')]\n"
-     ]
-    }
-   ],
-   "source": [
-    "with open(\"test_questions.txt\",\"r\") as infile:\n",
-    "    data = json.load(infile)\n",
-    "print(data[0])\n",
-    "\n",
-    "test_log = []\n",
-    "for i,t in enumerate(data):\n",
-    "    print(i)\n",
-    "    temp_answer, answer = full_chain_single_question(t['question'])\n",
-    "    test_log.append({'desired topic':t['desired'],\n",
-    "           'question':t['question'],\n",
-    "           'first answer':temp_answer,\n",
-    "           'final answer':answer})\n",
-    "with open(\"test_results.json\",\"w\") as outfile:\n",
-    "    json.dump(test_log,outfile)"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.10.12"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "d:\\Program\\Anaconda\\envs\\python_project\\lib\\site-packages\\tqdm\\auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
+      "  from .autonotebook import tqdm as notebook_tqdm\n",
+      "d:\\Program\\Anaconda\\envs\\python_project\\lib\\site-packages\\huggingface_hub\\file_download.py:1132: FutureWarning: `resume_download` is deprecated and will be removed in version 1.0.0. Downloads always resume when possible. If you want to force a new download, use `force_download=True`.\n",
+      "  warnings.warn(\n",
+      "d:\\Program\\Anaconda\\envs\\python_project\\lib\\site-packages\\huggingface_hub\\file_download.py:1132: FutureWarning: `resume_download` is deprecated and will be removed in version 1.0.0. Downloads always resume when possible. If you want to force a new download, use `force_download=True`.\n",
+      "  warnings.warn(\n"
+     ]
+    }
+   ],
+   "source": [
+    "import google.generativeai as genai\n",
+    "import arxiv_bot_utils as utils\n",
+    "import os\n",
+    "from getpass import getpass\n",
+    "import json\n",
+    "#chỉ là import một cách bình thường\n",
+    "#nội dung là "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "models/gemini-1.0-pro\n",
+      "models/gemini-1.0-pro-001\n",
+      "models/gemini-1.0-pro-latest\n",
+      "models/gemini-1.0-pro-vision-latest\n",
+      "models/gemini-1.5-pro-latest\n",
+      "models/gemini-pro\n",
+      "models/gemini-pro-vision\n"
+     ]
+    }
+   ],
+   "source": [
+    "os.environ['GEMINI_API_KEY'] = getpass(\"Input your API key: \")\n",
+    "# gán biến môi trường luôn\n",
+    "gemini_api_key = os.getenv(\"GEMINI_API_KEY\") # string trong môi trường\n",
+    "if not gemini_api_key:\n",
+    "    raise ValueError(\n",
+    "            \"Gemini API Key not provided. Please provide GEMINI_API_KEY as an environment variable\"\n",
+    "        )\n",
+    "genai.configure(api_key=gemini_api_key)\n",
+    "for m in genai.list_models():\n",
+    "  if 'generateContent' in m.supported_generation_methods:\n",
+    "    print(m.name)\n",
+    "    #models nằm trên máy chủ\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "config = genai.GenerationConfig(max_output_tokens=2048,\n",
+    "                                temperature=0.7)\n",
+    "safety_settings = [\n",
+    "    {\n",
+    "        \"category\": \"HARM_CATEGORY_DANGEROUS\",\n",
+    "        \"threshold\": \"BLOCK_NONE\",\n",
+    "    },\n",
+    "    {\n",
+    "        \"category\": \"HARM_CATEGORY_HARASSMENT\",\n",
+    "        \"threshold\": \"BLOCK_NONE\",\n",
+    "    },\n",
+    "    {\n",
+    "        \"category\": \"HARM_CATEGORY_HATE_SPEECH\",\n",
+    "        \"threshold\": \"BLOCK_NONE\",\n",
+    "    },\n",
+    "    {\n",
+    "        \"category\": \"HARM_CATEGORY_SEXUALLY_EXPLICIT\",\n",
+    "        \"threshold\": \"BLOCK_NONE\",\n",
+    "    },\n",
+    "    {\n",
+    "        \"category\": \"HARM_CATEGORY_DANGEROUS_CONTENT\",\n",
+    "        \"threshold\": \"BLOCK_NONE\",\n",
+    "    },\n",
+    "]\n",
+    "model = genai.GenerativeModel(\"gemini-pro\",\n",
+    "                              generation_config=config,\n",
+    "                              safety_settings=safety_settings)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def extract_keyword_prompt(query):\n",
+    "    \"\"\"A prompt that return a JSON block as arguments for querying database\"\"\"\n",
+    "\n",
+    "    prompt = (\n",
+    "        \"\"\"[INST] SYSTEM: You are an assistant that choose only one action below based on guest question.\n",
+    "   1. If the guest question is asking for a single specific document or article with explicit title, you need to respond the information in JSON format with 2 keys \"title\", \"author\" if found any above. The authors are separated with the word 'and'. \n",
+    "   2. If the guest question is asking for relevant informations about a topic, you need to respond the information in JSON format with 2 keys \"keywords\", \"description\", include a list of keywords represent the main academic topic, \\\n",
+    "     and a description about the main topic. You may paraphrase the keywords to add more. \\\n",
+    "   3. If the guest is not asking for any informations or documents, you need to respond with a polite answer in JSON format with 1 key \"answer\".\n",
+    "   QUESTION: '{query}'\n",
+    "   [/INST]\n",
+    "   ANSWER: \n",
+    "   \"\"\"\n",
+    "    ).format(query=query)\n",
+    "\n",
+    "    return prompt\n",
+    "\n",
+    "def make_answer_prompt(input, contexts):\n",
+    "    \"\"\"A prompt that return the final answer, based on the queried context\"\"\"\n",
+    "\n",
+    "    prompt = (\n",
+    "        \"\"\"[INST] You are a library assistant that help to search articles and documents based on user's question.\n",
+    "  From guest's question, you have found some records and documents that may help. Now you need to answer the guest with the information found.\n",
+    "  If no information found in the database, you may generate some other recommendation related to user's question using your own knowledge. Each article or paper must have a link to the pdf download page.\n",
+    "  You should answer in a conversational form politely.\n",
+    "  QUESTION: '{input}'\n",
+    "  INFORMATION: '{contexts}'\n",
+    "  [/INST]\n",
+    "  ANSWER:\n",
+    "  \"\"\"\n",
+    "    ).format(input=input, contexts=contexts)\n",
+    "\n",
+    "    return prompt"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def response(args):\n",
+    "    \"\"\"Create response context, based on input arguments\"\"\"\n",
+    "    keys = list(dict.keys(args))\n",
+    "    if \"answer\" in keys:\n",
+    "        return args['answer'], None  # trả lời trực tiếp\n",
+    "     \n",
+    "    if \"keywords\" in keys:\n",
+    "        # perform query\n",
+    "        query_texts = args[\"description\"]\n",
+    "        keywords = args[\"keywords\"]\n",
+    "        results = utils.db.query_relevant(keywords=keywords, query_texts=query_texts)\n",
+    "        # print(results)\n",
+    "        ids = results['metadatas'][0]\n",
+    "        if len(ids) == 0:\n",
+    "            # go crawl some\n",
+    "            new_records = utils.crawl_arxiv(keyword_list=keywords, max_results=10)\n",
+    "            print(\"Got new records: \",len(new_records))\n",
+    "            if type(new_records) == str:\n",
+    "                return \"Error occured, information not found\", new_records\n",
+    "            utils.db.add(new_records)\n",
+    "            utils.sqldb.add(new_records)\n",
+    "            results = utils.db.query_relevant(keywords=keywords, query_texts=query_texts)\n",
+    "            ids = results['metadatas'][0]\n",
+    "            print(\"Re-queried on chromadb, results: \",ids)\n",
+    "        paper_id = [id['paper_id'] for id in ids]\n",
+    "        paper_info = utils.sqldb.query_id(paper_id)\n",
+    "        print(paper_info)\n",
+    "        records = [] # get title (2), author (3), link (6)\n",
+    "        result_string = \"\"\n",
+    "        if paper_info:\n",
+    "            for i in range(len(paper_info)):\n",
+    "                result_string += \"Title: {}, Author: {}, Link: {}\".format(paper_info[i][2],paper_info[i][3],paper_info[i][6])\n",
+    "                records.append([paper_info[i][2],paper_info[i][3],paper_info[i][6]])\n",
+    "                return result_string, records\n",
+    "        else:\n",
+    "            return \"Information not found\", \"Information not found\"\n",
+    "        # invoke llm and return result\n",
+    "\n",
+    "    if \"title\" in keys:\n",
+    "        title = args['title']\n",
+    "        authors = utils.authors_str_to_list(args['author'])\n",
+    "        paper_info = utils.sqldb.query(title = title,author = authors)\n",
+    "        # if query not found then go crawl brh\n",
+    "        # print(paper_info)\n",
+    "\n",
+    "        if len(paper_info) == 0:\n",
+    "            new_records = utils.crawl_exact_paper(title=title,author=authors)\n",
+    "            print(\"Got new records: \",len(new_records))\n",
+    "            if type(new_records) == str:\n",
+    "                # print(new_records)\n",
+    "                return \"Error occured, information not found\", \"Information not found\"\n",
+    "            utils.db.add(new_records)\n",
+    "            utils.sqldb.add(new_records)\n",
+    "            paper_info = utils.sqldb.query(title = title,author = authors)\n",
+    "            print(\"Re-queried on chromadb, results: \",paper_info)\n",
+    "        # -------------------------------------\n",
+    "        records = [] # get title (2), author (3), link (6)\n",
+    "        result_string = \"\"\n",
+    "        for i in range(len(paper_info)):\n",
+    "            result_string += \"Title: {}, Author: {}, Link: {}\".format(paper_info[i][2],paper_info[i][3],paper_info[i][6])\n",
+    "            records.append([paper_info[i][2],paper_info[i][3],paper_info[i][6]])\n",
+    "        # process results:\n",
+    "        if len(result_string) == 0:\n",
+    "            return \"Information not found\", \"Information not found\"\n",
+    "        return result_string, records\n",
+    "        # invoke llm and return result"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def full_chain_single_question(input_prompt):\n",
+    "    try:\n",
+    "        first_prompt = extract_keyword_prompt(input_prompt)\n",
+    "        temp_answer = model.generate_content(first_prompt).text\n",
+    "\n",
+    "        args = json.loads(utils.trimming(temp_answer))\n",
+    "        contexts, results = response(args)\n",
+    "        if not results:\n",
+    "            print(contexts)\n",
+    "        else:\n",
+    "            output_prompt = make_answer_prompt(input_prompt,contexts)\n",
+    "            answer = model.generate_content(output_prompt).text\n",
+    "        return temp_answer, answer\n",
+    "    except Exception as e:\n",
+    "        print(e)\n",
+    "        return temp_answer, \"Error occured: \" + str(e)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[('1903.04824v1', 'computer science', 'Proceedings of the Fifth International Conference on Cloud and Robotics (ICCR2018)', ' Huaxi,  Zhang, Jacques Malenfan', '2019-03-12', '2019-03-12', 'http://arxiv.org/pdf/1903.04824v1'), ('1709.07597v1', 'economics', 'Inverse Reinforcement Learning with Conditional Choice Probabilities', 'Mohit Sharma, Kris M. Kitani, Joachim Groege', '2017-09-22', '2017-09-22', 'http://arxiv.org/pdf/1709.07597v1')]\n",
+      "Sure, here are some key papers on model predictive control for nonlinear systems:\n",
+      "\n",
+      "* **Nonlinear Model Predictive Control: A Survey** by Garcia, P.D., Prett, D.M., and Morari, M. (1989)\n",
+      "* **Model Predictive Control for Nonlinear Systems** by Camacho, E.F. and Bordons, C. (1999)\n",
+      "* **Nonlinear Model Predictive Control** by Rawlings, J.B. and Mayne, D.Q. (2009)\n",
+      "\n",
+      "As for recent reviews on the application of control theory to robotics, here are a few:\n",
+      "\n",
+      "* **Control of Robot Manipulators** by Spong, M.W., Hutchinson, S., and Vidyasagar, M. (2006)\n",
+      "* **Robotics: Modelling, Planning and Control** by Siciliano, B., Sciavicco, L., Villani, L., and Oriolo, G. (2010)\n",
+      "* **Control of Robot Arms** by Featherstone, R. (2014)\n",
+      "\n",
+      "I hope this information is helpful. Please let me know if you have any other questions.\n"
+     ]
+    }
+   ],
+   "source": [
+    "# test response, second step\n",
+    "input_prompt = \"Can you suggest some key papers on model predictive control for nonlinear systems, and are there any recent reviews on the application of control theory to robotics?\"\n",
+    "args = \"{\\n \\\"keywords\\\": [\\\"Model predictive control\\\", \\\"Nonlinear systems\\\", \\\"Robotics\\\", \\\"Control theory\\\"],\\n \\\"description\\\": \\\"Model predictive control (MPC) is a control algorithm that uses a model of the system to predict future behavior and optimize the control inputs. MPC is particularly well-suited for nonlinear systems, as it can handle the complex dynamics of these systems. In recent years, MPC has been increasingly applied to robotics, as it can improve the performance and safety of robotic systems. Control theory is a branch of mathematics that deals with the analysis and design of control systems. Control theory has been applied to a wide range of problems in robotics, including motion planning, trajectory tracking, and force control.\\\"\\n}\"\n",
+    "args = json.loads(args)\n",
+    "contexts, results = response(args)\n",
+    "if not results:\n",
+    "  # direct answer\n",
+    "  print(contexts)\n",
+    "else:\n",
+    "  output_prompt = make_answer_prompt(input_prompt,contexts)\n",
+    "  answer = model.generate_content(output_prompt).text\n",
+    "  print(answer)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'desired': 'Natural Language Processing (Computer Science)', 'question': 'What are some recent papers on deep learning architectures for text classification, and can you recommend any surveys or reviews on the topic?'}\n",
+      "0\n",
+      "[('1808.08121v1', 'computer science', 'An Improvement of Data Classification Using Random Multimodel Deep Learning (RMDL)', 'Mojtaba Heidarysafa, Kamran Kowsari, Donald E. Brown, Kiana Jafari Meimandi, Laura E. Barne', '2018-08-23', '2018-08-23', 'http://arxiv.org/pdf/1808.08121v1'), ('1904.08067v5', 'computer science', 'Text Classification Algorithms: A Survey', 'Kamran Kowsari, Kiana Jafari Meimandi, Mojtaba Heidarysafa, Sanjana Mendu, Laura E. Barnes, Donald E. Brow', '2020-05-20', '2019-04-17', 'http://arxiv.org/pdf/1904.08067v5'), ('2202.09144v1', 'computer science', 'Modelling the semantics of text in complex document layouts using graph transformer networks', 'Thomas Roland Barillot, Jacob Saks, Polena Lilyanova, Edward Torgas, Yachen Hu, Yuanqing Liu, Varun Balupuri, Paul Gaskel', '2022-02-18', '2022-02-18', 'http://arxiv.org/pdf/2202.09144v1')]\n",
+      "1\n",
+      "[('1601.04187v1', 'computer science', 'Conversion of Artificial Recurrent Neural Networks to Spiking Neural Networks for Low-power Neuromorphic Hardware', 'Peter U. Diehl, Guido Zarrella, Andrew Cassidy, Bruno U. Pedroni, Emre Neftc', '2016-01-16', '2016-01-16', 'http://arxiv.org/pdf/1601.04187v1'), ('1801.01093v3', 'economics', 'Comparing the Forecasting Performances of Linear Models for Electricity Prices with High RES Penetration', 'Angelica Gianfreda, Francesco Ravazzolo, Luca Rossin', '2019-11-12', '2018-01-03', 'http://arxiv.org/pdf/1801.01093v3'), ('2302.11093v1', 'electrical engineering and system science', 'Use Cases for Time-Frequency Image Representations and Deep Learning Techniques for Improved Signal Classification', 'Mehmet Parla', '2023-02-22', '2023-02-22', 'http://arxiv.org/pdf/2302.11093v1')]\n",
+      "2\n",
+      "[('1505.07907v4', 'economics', 'Linking Economic Complexity, Institutions and Income Inequality', 'D. Hartmann, M. R. Guevara, C. Jara-Figueroa, M. Aristaran, C. A. Hidalg', '2017-01-04', '2015-05-29', 'http://arxiv.org/pdf/1505.07907v4'), ('2107.06855v2', 'economics', 'Comparing Intellectual property policy in the Global North and South -- A one-size-fits-all policy for economic prosperity?', 'S Sidhartha Narayan, Malavika Ranjan, Madhumitha Raghurama', '2021-08-10', '2021-07-14', 'http://arxiv.org/pdf/2107.06855v2'), ('1910.11780v1', 'economics', 'Inequality in Turkey: Looking Beyond Growth', 'Bayram Cakir, Ipek Ergu', '2019-10-25', '2019-10-25', 'http://arxiv.org/pdf/1910.11780v1')]\n",
+      "3\n",
+      "[('1607.06583v2', 'computer science', \"Classification of Alzheimer's Disease Structural MRI Data by Deep Learning Convolutional Neural Networks\", 'Saman Sarraf, Ghassem Tofigh', '2017-05-19', '2016-07-22', 'http://arxiv.org/pdf/1607.06583v2'), ('2101.10265v1', 'computer science', 'Superiorities of Deep Extreme Learning Machines against Convolutional Neural Networks', 'Gokhan Altan, Yakup Kutl', '2021-01-21', '2021-01-21', 'http://arxiv.org/pdf/2101.10265v1'), ('2208.03143v1', 'computer science', 'Deep Learning and Health Informatics for Smart Monitoring and Diagnosis', 'Amin Gasm', '2022-08-05', '2022-08-05', 'http://arxiv.org/pdf/2208.03143v1')]\n",
+      "4\n",
+      "[('2302.06584v3', 'computer science', 'Thermodynamic AI and the fluctuation frontier', 'Patrick J. Coles, Collin Szczepanski, Denis Melanson, Kaelan Donatella, Antonio J. Martinez, Faris Sbah', '2023-06-13', '2023-02-09', 'http://arxiv.org/pdf/2302.06584v3'), ('2307.12298v1', 'computer science', 'Stabilization and Dissipative Information Transfer of a Superconducting Kerr-Cat Qubit', 'Ufuk Korkmaz, Deniz Türkpenç', '2023-07-23', '2023-07-23', 'http://arxiv.org/pdf/2307.12298v1'), ('2106.10421v1', 'computer science', 'QFCNN: Quantum Fourier Convolutional Neural Network', 'Feihong Shen, Jun Li', '2021-06-19', '2021-06-19', 'http://arxiv.org/pdf/2106.10421v1')]\n",
+      "5\n",
+      "[('2308.16539v2', 'computer science', 'On a Connection between Differential Games, Optimal Control, and Energy-based Models for Multi-Agent Interactions', 'Christopher Diehl, Tobias Klosek, Martin Krüger, Nils Murzyn, Torsten Bertra', '2023-10-16', '2023-08-31', 'http://arxiv.org/pdf/2308.16539v2'), ('2404.12474v1', 'computer science', 'Learning a Stable, Safe, Distributed Feedback Controller for a Heterogeneous Platoon of Vehicles', 'Michael H. Shaham, Taskin Padi', '2024-04-18', '2024-04-18', 'http://arxiv.org/pdf/2404.12474v1'), ('2008.13221v1', 'computer science', 'Human-in-the-Loop Methods for Data-Driven and Reinforcement Learning Systems', 'Vinicius G. Goeck', '2020-08-30', '2020-08-30', 'http://arxiv.org/pdf/2008.13221v1')]\n",
+      "6\n",
+      "[('1911.06206v3', 'economics', 'Bayesian state-space modeling for analyzing heterogeneous network effects of US monetary policy', 'Niko Hauzenberger, Michael Pfarrhofe', '2020-09-10', '2019-11-14', 'http://arxiv.org/pdf/1911.06206v3'), ('2302.14114v1', 'economics', 'Econometric assessment of the monetary policy shocks in Morocco: Evidence from a Bayesian Factor-Augmented VAR', 'Marouane Daou', '2023-02-27', '2023-02-27', 'http://arxiv.org/pdf/2302.14114v1'), ('2311.11858v1', 'economics', 'Theory coherent shrinkage of Time-Varying Parameters in VARs', 'Andrea Renzett', '2023-11-20', '2023-11-20', 'http://arxiv.org/pdf/2311.11858v1')]\n",
+      "7\n",
+      "[('2310.03365v2', 'computer science', 'Swin-Tempo: Temporal-Aware Lung Nodule Detection in CT Scans as Video Sequences Using Swin Transformer-Enhanced UNet', 'Hossein Jafari, Karim Faez, Hamidreza Amindava', '2023-10-14', '2023-10-05', 'http://arxiv.org/pdf/2310.03365v2'), ('1808.08531v1', 'computer science', 'DeepTracker: Visualizing the Training Process of Convolutional Neural Networks', 'Dongyu Liu, Weiwei Cui, Kai Jin, Yuxiao Guo, Huamin Q', '2018-08-26', '2018-08-26', 'http://arxiv.org/pdf/1808.08531v1'), ('2105.10448v1', 'computer science', 'Distinguishing artefacts: evaluating the saturation point of convolutional neural networks', 'Ric Real, James Gopsill, David Jones, Chris Snider, Ben Hick', '2021-05-21', '2021-05-21', 'http://arxiv.org/pdf/2105.10448v1')]\n",
+      "8\n",
+      "Got new records:  10\n",
+      "Re-queried on chromadb, results:  []\n",
+      "None\n",
+      "9\n",
+      "[('2403.07017v1', 'computer science', 'Mathematics of multi-agent learning systems at the interface of game theory and artificial intelligence', 'Long Wang, Feng Fu, Xingru Che', '2024-03-09', '2024-03-09', 'http://arxiv.org/pdf/2403.07017v1'), ('2210.02205v1', 'computer science', 'Game Theoretic Rating in N-player general-sum games with Equilibria', 'Luke Marris, Marc Lanctot, Ian Gemp, Shayegan Omidshafiei, Stephen McAleer, Jerome Connor, Karl Tuyls, Thore Graepe', '2022-10-05', '2022-10-05', 'http://arxiv.org/pdf/2210.02205v1'), ('2212.05357v3', 'economics', 'On Blockchain We Cooperate: An Evolutionary Game Perspective', 'Luyao Zhang, Xinyu Tia', '2023-01-19', '2022-12-10', 'http://arxiv.org/pdf/2212.05357v3')]\n"
+     ]
+    }
+   ],
+   "source": [
+    "with open(\"test_questions.txt\",\"r\") as infile:\n",
+    "    data = json.load(infile)\n",
+    "print(data[0])\n",
+    "\n",
+    "test_log = []\n",
+    "for i,t in enumerate(data):\n",
+    "    print(i)\n",
+    "    temp_answer, answer = full_chain_single_question(t['question'])\n",
+    "    test_log.append({'desired topic':t['desired'],\n",
+    "           'question':t['question'],\n",
+    "           'first answer':temp_answer,\n",
+    "           'final answer':answer})\n",
+    "with open(\"test_results.json\",\"w\") as outfile:\n",
+    "    json.dump(test_log,outfile)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

chat/consumers.py

@@ -1,21 +1,25 @@
 import json
-from . import model_manage as md
-from chat.arxiv_bot.arxiv_bot_utils import ArxivSQL
+from . import model_manage2 as md
 from channels.generic.websocket import WebsocketConsumer
 
 
 class ChatConsumer(WebsocketConsumer):
     def connect(self):
         self.accept()
-        self.db_instance = ArxivSQL()
+        self.model, self.session = md.init_model("auto")
         
     def disconnect(self, close_code):
+        del self.model, self.session
         pass
+    
     def receive(self, text_data):
         text_data_json = json.loads(text_data)
         message = text_data_json["messages"]
         print(message)
-        record, messagee = md.full_chain_history_question(message, self.db_instance)
-        print("First answer: ",record)
-        self.send(text_data=json.dumps({"message": messagee}))
+        question = message[-1]['content']
+        response, history_state = md.full_chain_history_question(question, self.session, mode="auto")
+        # print("First answer: ",response)
+        print("Session history:")
+        md.print_history(history_state)
+        self.send(text_data=json.dumps({"message": response}))
         

chat/model_manage.py

@@ -1,271 +1,271 @@
-# my_app/model_manager.py
-import google.generativeai as genai
-import chat.arxiv_bot.arxiv_bot_utils as utils
-import json
+# # my_app/model_manager.py
+# import google.generativeai as genai
+# import chat.arxiv_bot.arxiv_bot_utils as utils
+# import json
 
-model = None
+# model = None
 
-model_retrieval = None
+# model_retrieval = None
 
-model_answer = None
+# model_answer = None
 
-RETRIEVAL_INSTRUCT = """You are an auto chatbot that response with only one action below based on user question.
-   1. If the guest question is asking about a science topic, you need to respond the information in JSON schema below:
-        {
-            "keywords": [a list of string keywords about the topic],
-            "description": "a paragraph describing the topic in about 50 to 100 words"
-        }
-   2. If the guest is not asking for any informations or documents, you need to respond in JSON schema below:
-        {
-            "answer": "your answer to the user question"
-        }"""
+# RETRIEVAL_INSTRUCT = """You are an auto chatbot that response with only one action below based on user question.
+#    1. If the guest question is asking about a science topic, you need to respond the information in JSON schema below:
+#         {
+#             "keywords": [a list of string keywords about the topic],
+#             "description": "a paragraph describing the topic in about 50 to 100 words"
+#         }
+#    2. If the guest is not asking for any informations or documents, you need to respond in JSON schema below:
+#         {
+#             "answer": "your answer to the user question"
+#         }"""
 
-ANSWER_INSTRUCT = """You are a library assistant that help answering customer question based on the information given.
-        You always answer in a conversational form naturally and politely.
-        You must introduce all the records given, each must contain title, authors and the link to the pdf file."""
+# ANSWER_INSTRUCT = """You are a library assistant that help answering customer question based on the information given.
+#         You always answer in a conversational form naturally and politely.
+#         You must introduce all the records given, each must contain title, authors and the link to the pdf file."""
 
-def create_model():
-    with open("apikey.txt","r") as apikey:
-        key = apikey.readline()
-        genai.configure(api_key=key)
-    for m in genai.list_models():
-        if 'generateContent' in m.supported_generation_methods:
-            print(m.name)
-    print("He was there")
-    config = genai.GenerationConfig(max_output_tokens=2048,
-                                temperature=1.0)
-    safety_settings = [
-        {
-            "category": "HARM_CATEGORY_DANGEROUS",
-            "threshold": "BLOCK_NONE",
-        },
-        {
-            "category": "HARM_CATEGORY_HARASSMENT",
-            "threshold": "BLOCK_NONE",
-        },
-        {
-            "category": "HARM_CATEGORY_HATE_SPEECH",
-            "threshold": "BLOCK_NONE",
-        },
-        {
-            "category": "HARM_CATEGORY_SEXUALLY_EXPLICIT",
-            "threshold": "BLOCK_NONE",
-        },
-        {
-            "category": "HARM_CATEGORY_DANGEROUS_CONTENT",
-            "threshold": "BLOCK_NONE",
-        },
-    ]
-    global model, model_retrieval, model_answer
-    model = genai.GenerativeModel("gemini-1.5-pro-latest",
-                                generation_config=config,
-                                safety_settings=safety_settings)
-    model_retrieval = genai.GenerativeModel("gemini-1.5-pro-latest",
-                                            generation_config=config,
-                                            safety_settings=safety_settings,
-                                            system_instruction=RETRIEVAL_INSTRUCT)
-    model_answer = genai.GenerativeModel("gemini-1.5-pro-latest",
-                                         generation_config=config,
-                                         safety_settings=safety_settings,
-                                         system_instruction=ANSWER_INSTRUCT)
-    return model, model_answer, model_retrieval
+# def create_model():
+#     with open("apikey.txt","r") as apikey:
+#         key = apikey.readline()
+#         genai.configure(api_key=key)
+#     for m in genai.list_models():
+#         if 'generateContent' in m.supported_generation_methods:
+#             print(m.name)
+#     print("He was there")
+#     config = genai.GenerationConfig(max_output_tokens=2048,
+#                                 temperature=1.0)
+#     safety_settings = [
+#         {
+#             "category": "HARM_CATEGORY_DANGEROUS",
+#             "threshold": "BLOCK_NONE",
+#         },
+#         {
+#             "category": "HARM_CATEGORY_HARASSMENT",
+#             "threshold": "BLOCK_NONE",
+#         },
+#         {
+#             "category": "HARM_CATEGORY_HATE_SPEECH",
+#             "threshold": "BLOCK_NONE",
+#         },
+#         {
+#             "category": "HARM_CATEGORY_SEXUALLY_EXPLICIT",
+#             "threshold": "BLOCK_NONE",
+#         },
+#         {
+#             "category": "HARM_CATEGORY_DANGEROUS_CONTENT",
+#             "threshold": "BLOCK_NONE",
+#         },
+#     ]
+#     global model, model_retrieval, model_answer
+#     model = genai.GenerativeModel("gemini-1.5-pro-latest",
+#                                 generation_config=config,
+#                                 safety_settings=safety_settings)
+#     model_retrieval = genai.GenerativeModel("gemini-1.5-pro-latest",
+#                                             generation_config=config,
+#                                             safety_settings=safety_settings,
+#                                             system_instruction=RETRIEVAL_INSTRUCT)
+#     model_answer = genai.GenerativeModel("gemini-1.5-pro-latest",
+#                                          generation_config=config,
+#                                          safety_settings=safety_settings,
+#                                          system_instruction=ANSWER_INSTRUCT)
+#     return model, model_answer, model_retrieval
 
-def get_model():
-    global model, model_answer, model_retrieval
-    if model is None:
-        # Khởi tạo model ở đây
-        model, model_answer, model_retrieval = create_model()  # Giả sử create_model là hàm tạo model của bạn
-    return model, model_answer, model_retrieval
+# def get_model():
+#     global model, model_answer, model_retrieval
+#     if model is None:
+#         # Khởi tạo model ở đây
+#         model, model_answer, model_retrieval = create_model()  # Giả sử create_model là hàm tạo model của bạn
+#     return model, model_answer, model_retrieval
 
-def extract_keyword_prompt(query):
-    """A prompt that return a JSON block as arguments for querying database"""
+# def extract_keyword_prompt(query):
+#     """A prompt that return a JSON block as arguments for querying database"""
 
-    prompt = """[INST] SYSTEM: You are an auto chatbot that response with only one action below based on user question.
-   1. If the guest question is asking about a science topic, you need to respond the information in JSON schema below:
-        {
-            "keywords": [a list of string keywords about the topic],
-            "description": "a paragraph describing the topic in about 50 to 100 words"
-        }
-   2. If the guest is not asking for any informations or documents, you need to respond in JSON schema below:
-        {
-            "answer": "your answer to the user question"
-        }
-   QUESTION: """ + query + """[/INST]
-   ANSWER: """
-    return prompt
+#     prompt = """[INST] SYSTEM: You are an auto chatbot that response with only one action below based on user question.
+#    1. If the guest question is asking about a science topic, you need to respond the information in JSON schema below:
+#         {
+#             "keywords": [a list of string keywords about the topic],
+#             "description": "a paragraph describing the topic in about 50 to 100 words"
+#         }
+#    2. If the guest is not asking for any informations or documents, you need to respond in JSON schema below:
+#         {
+#             "answer": "your answer to the user question"
+#         }
+#    QUESTION: """ + query + """[/INST]
+#    ANSWER: """
+#     return prompt
 
-def make_answer_prompt(input, contexts):
-    """A prompt that return the final answer, based on the queried context"""
+# def make_answer_prompt(input, contexts):
+#     """A prompt that return the final answer, based on the queried context"""
 
-    prompt = (
-        """[INST] You are a library assistant that help answering customer QUESTION based on the INFORMATION given.
-        You always answer in a conversational form naturally and politely.
-        You must introduce all the records given, each must contain title, authors and the link to the pdf file.
-  QUESTION: {input}
-  INFORMATION: '{contexts}'
-  [/INST]
-  ANSWER:
-  """
-    ).format(input=input, contexts=contexts)
-    return prompt
+#     prompt = (
+#         """[INST] You are a library assistant that help answering customer QUESTION based on the INFORMATION given.
+#         You always answer in a conversational form naturally and politely.
+#         You must introduce all the records given, each must contain title, authors and the link to the pdf file.
+#   QUESTION: {input}
+#   INFORMATION: '{contexts}'
+#   [/INST]
+#   ANSWER:
+#   """
+#     ).format(input=input, contexts=contexts)
+#     return prompt
 
-def retrieval_chat_template(question):
-    return {
-        "role":"user",
-        "parts":[f"QUESTION: {question} \n ANSWER:"]
-    }
+# def retrieval_chat_template(question):
+#     return {
+#         "role":"user",
+#         "parts":[f"QUESTION: {question} \n ANSWER:"]
+#     }
 
-def answer_chat_template(question, contexts):
-    return {
-        "role":"user",
-        "parts":[f"QUESTION: {question} \n INFORMATION: {contexts} \n ANSWER:"]
-    }
+# def answer_chat_template(question, contexts):
+#     return {
+#         "role":"user",
+#         "parts":[f"QUESTION: {question} \n INFORMATION: {contexts} \n ANSWER:"]
+#     }
 
-def response(args, db_instance):
-    """Create response context, based on input arguments"""
-    keys = list(dict.keys(args))
-    if "answer" in keys:
-        return args['answer'], None  # trả lời trực tiếp
+# def response(args, db_instance):
+#     """Create response context, based on input arguments"""
+#     keys = list(dict.keys(args))
+#     if "answer" in keys:
+#         return args['answer'], None  # trả lời trực tiếp
      
-    if "keywords" in keys:
-        # perform query
-        query_texts = args["description"]
-        keywords = args["keywords"]
-        results = utils.db.query_relevant(keywords=keywords, query_texts=query_texts)
-        # print(results)
-        ids = results['metadatas'][0]
-        if len(ids) == 0:
-            # go crawl some
-            new_records = utils.crawl_arxiv(keyword_list=keywords, max_results=10)
-            print("Got new records: ",len(new_records))
-            if type(new_records) == str:
-                return "Error occured, information not found", new_records
-            utils.db.add(new_records)
-            db_instance.add(new_records)
-            results = utils.db.query_relevant(keywords=keywords, query_texts=query_texts)
-            ids = results['metadatas'][0]
-            print("Re-queried on chromadb, results: ",ids)
-        paper_id = [id['paper_id'] for id in ids]
-        paper_info = db_instance.query_id(paper_id)
-        print(paper_info)
-        records = [] # get title (2), author (3), link (6)
-        result_string = ""
-        if paper_info:
-            for i in range(len(paper_info)):
-                result_string += "Record no.{} - Title: {}, Author: {}, Link: {}, ".format(i+1,paper_info[i][2],paper_info[i][3],paper_info[i][6])
-                id = paper_info[i][0]
-                selected_document = utils.db.query_exact(id)["documents"]
-                doc_str = "Summary:"
-                for doc in selected_document:
-                    doc_str+= doc + " "
-                result_string += doc_str
-                records.append([paper_info[i][2],paper_info[i][3],paper_info[i][6]])
-            return result_string, records
-        else:
-            return "Information not found", "Information not found"
-        # invoke llm and return result
-
-    # if "title" in keys:
-    #     title = args['title']
-    #     authors = utils.authors_str_to_list(args['author'])
-    #     paper_info = db_instance.query(title = title,author = authors)
-    #     # if query not found then go crawl brh
-    #     # print(paper_info)
-
-    #     if len(paper_info) == 0:
-    #         new_records = utils.crawl_exact_paper(title=title,author=authors)
-    #         print("Got new records: ",len(new_records))
-    #         if type(new_records) == str:
-    #             # print(new_records)
-    #             return "Error occured, information not found", "Information not found"
-    #         utils.db.add(new_records)
-    #         db_instance.add(new_records)
-    #         paper_info = db_instance.query(title = title,author = authors)
-    #         print("Re-queried on chromadb, results: ",paper_info)
-    #     # -------------------------------------
-    #     records = [] # get title (2), author (3), link (6)
-    #     result_string = ""
-    #     for i in range(len(paper_info)):
-    #         result_string += "Title: {}, Author: {}, Link: {}".format(paper_info[i][2],paper_info[i][3],paper_info[i][6])
-    #         records.append([paper_info[i][2],paper_info[i][3],paper_info[i][6]])
-    #     # process results:
-    #     if len(result_string) == 0:
-    #         return "Information not found", "Information not found"
-    #     return result_string, records
-        # invoke llm and return result
-
-def full_chain_single_question(input_prompt, db_instance):
-    try:
-        first_prompt = extract_keyword_prompt(input_prompt)
-        temp_answer = model.generate_content(first_prompt).text
+#     if "keywords" in keys:
+#         # perform query
+#         query_texts = args["description"]
+#         keywords = args["keywords"]
+#         results = utils.db.query_relevant(keywords=keywords, query_texts=query_texts)
+#         # print(results)
+#         ids = results['metadatas'][0]
+#         if len(ids) == 0:
+#             # go crawl some
+#             new_records = utils.crawl_arxiv(keyword_list=keywords, max_results=10)
+#             print("Got new records: ",len(new_records))
+#             if type(new_records) == str:
+#                 return "Error occured, information not found", new_records
+#             utils.db.add(new_records)
+#             db_instance.add(new_records)
+#             results = utils.db.query_relevant(keywords=keywords, query_texts=query_texts)
+#             ids = results['metadatas'][0]
+#             print("Re-queried on chromadb, results: ",ids)
+#         paper_id = [id['paper_id'] for id in ids]
+#         paper_info = db_instance.query_id(paper_id)
+#         print(paper_info)
+#         records = [] # get title (2), author (3), link (6)
+#         result_string = ""
+#         if paper_info:
+#             for i in range(len(paper_info)):
+#                 result_string += "Record no.{} - Title: {}, Author: {}, Link: {}, ".format(i+1,paper_info[i][2],paper_info[i][3],paper_info[i][6])
+#                 id = paper_info[i][0]
+#                 selected_document = utils.db.query_exact(id)["documents"]
+#                 doc_str = "Summary:"
+#                 for doc in selected_document:
+#                     doc_str+= doc + " "
+#                 result_string += doc_str
+#                 records.append([paper_info[i][2],paper_info[i][3],paper_info[i][6]])
+#             return result_string, records
+#         else:
+#             return "Information not found", "Information not found"
+#         # invoke llm and return result
 
-        args = json.loads(utils.trimming(temp_answer))
-        contexts, results = response(args, db_instance)
-        if not results:
-            # print(contexts)
-            return "Random question, direct return", contexts
-        else:
-            output_prompt = make_answer_prompt(input_prompt,contexts)
-            answer = model.generate_content(output_prompt).text
-            return temp_answer, answer
-    except Exception as e:
-        # print(e)
-        return temp_answer, "Error occured: " + str(e)
-    
+#     # if "title" in keys:
+#     #     title = args['title']
+#     #     authors = utils.authors_str_to_list(args['author'])
+#     #     paper_info = db_instance.query(title = title,author = authors)
+#     #     # if query not found then go crawl brh
+#     #     # print(paper_info)
 
-def format_chat_history_from_web(chat_history: list):
-    temp_chat = []
-    for message in chat_history:
-        temp_chat.append(
-            {
-                "role": message["role"],
-                "parts": [message["content"]]
-            }
-        )
-    return temp_chat
+#     #     if len(paper_info) == 0:
+#     #         new_records = utils.crawl_exact_paper(title=title,author=authors)
+#     #         print("Got new records: ",len(new_records))
+#     #         if type(new_records) == str:
+#     #             # print(new_records)
+#     #             return "Error occured, information not found", "Information not found"
+#     #         utils.db.add(new_records)
+#     #         db_instance.add(new_records)
+#     #         paper_info = db_instance.query(title = title,author = authors)
+#     #         print("Re-queried on chromadb, results: ",paper_info)
+#     #     # -------------------------------------
+#     #     records = [] # get title (2), author (3), link (6)
+#     #     result_string = ""
+#     #     for i in range(len(paper_info)):
+#     #         result_string += "Title: {}, Author: {}, Link: {}".format(paper_info[i][2],paper_info[i][3],paper_info[i][6])
+#     #         records.append([paper_info[i][2],paper_info[i][3],paper_info[i][6]])
+#     #     # process results:
+#     #     if len(result_string) == 0:
+#     #         return "Information not found", "Information not found"
+#     #     return result_string, records
+#         # invoke llm and return result
 
-# def full_chain_history_question(chat_history: list, db_instance):
+# def full_chain_single_question(input_prompt, db_instance):
 #     try:
-#         temp_chat = format_chat_history_from_web(chat_history)
-#         print('Extracted temp chat: ',temp_chat)
-#         first_prompt = extract_keyword_prompt(temp_chat[-1]["parts"][0])
+#         first_prompt = extract_keyword_prompt(input_prompt)
 #         temp_answer = model.generate_content(first_prompt).text
 
 #         args = json.loads(utils.trimming(temp_answer))
 #         contexts, results = response(args, db_instance)
-#         print('Context extracted: ',contexts)
 #         if not results:
+#             # print(contexts)
 #             return "Random question, direct return", contexts
 #         else:
-#             QA_Prompt = make_answer_prompt(temp_chat[-1]["parts"][0], contexts)
-#             temp_chat[-1]["parts"] = QA_Prompt
-#             print(temp_chat)
-#             answer = model.generate_content(temp_chat).text
+#             output_prompt = make_answer_prompt(input_prompt,contexts)
+#             answer = model.generate_content(output_prompt).text
 #             return temp_answer, answer
 #     except Exception as e:
 #         # print(e)
 #         return temp_answer, "Error occured: " + str(e)
+    
+
+# def format_chat_history_from_web(chat_history: list):
+#     temp_chat = []
+#     for message in chat_history:
+#         temp_chat.append(
+#             {
+#                 "role": message["role"],
+#                 "parts": [message["content"]]
+#             }
+#         )
+#     return temp_chat
+
+# # def full_chain_history_question(chat_history: list, db_instance):
+# #     try:
+# #         temp_chat = format_chat_history_from_web(chat_history)
+# #         print('Extracted temp chat: ',temp_chat)
+# #         first_prompt = extract_keyword_prompt(temp_chat[-1]["parts"][0])
+# #         temp_answer = model.generate_content(first_prompt).text
 
-def full_chain_history_question(chat_history: list, db_instance):
-    try:
-        temp_chat = format_chat_history_from_web(chat_history)
-        question = temp_chat[-1]['parts'][0]
-        first_answer = model_retrieval.generate_content(temp_chat).text
+# #         args = json.loads(utils.trimming(temp_answer))
+# #         contexts, results = response(args, db_instance)
+# #         print('Context extracted: ',contexts)
+# #         if not results:
+# #             return "Random question, direct return", contexts
+# #         else:
+# #             QA_Prompt = make_answer_prompt(temp_chat[-1]["parts"][0], contexts)
+# #             temp_chat[-1]["parts"] = QA_Prompt
+# #             print(temp_chat)
+# #             answer = model.generate_content(temp_chat).text
+# #             return temp_answer, answer
+# #     except Exception as e:
+# #         # print(e)
+# #         return temp_answer, "Error occured: " + str(e)
+
+# def full_chain_history_question(chat_history: list, db_instance):
+#     try:
+#         temp_chat = format_chat_history_from_web(chat_history)
+#         question = temp_chat[-1]['parts'][0]
+#         first_answer = model_retrieval.generate_content(temp_chat).text
         
-        print(first_answer)
-        args = json.loads(utils.trimming(first_answer))
+#         print(first_answer)
+#         args = json.loads(utils.trimming(first_answer))
 
-        contexts, results = response(args, db_instance)
-        if not results:
-            return "Random question, direct return", contexts
-        else:
-            print('Context to answers: ',contexts)
-            answer_chat = answer_chat_template(question, contexts)
-            temp_chat[-1] = answer_chat
-            answer = model_answer.generate_content(temp_chat).text
-            return first_answer, answer
-    except Exception as e:
-        if first_answer:
-            return first_answer, "Error occured: " + str(e)
-        else:
-            return "No answer", "Error occured: " + str(e)
+#         contexts, results = response(args, db_instance)
+#         if not results:
+#             return "Random question, direct return", contexts
+#         else:
+#             print('Context to answers: ',contexts)
+#             answer_chat = answer_chat_template(question, contexts)
+#             temp_chat[-1] = answer_chat
+#             answer = model_answer.generate_content(temp_chat).text
+#             return first_answer, answer
+#     except Exception as e:
+#         if first_answer:
+#             return first_answer, "Error occured: " + str(e)
+#         else:
+#             return "No answer", "Error occured: " + str(e)

chat/model_manage2.py

@@ -0,0 +1,174 @@
+import chat.arxiv_bot.arxiv_bot_utils2 as utils
+import google.generativeai as genai
+import json
+import os
+from google.generativeai.types import content_types
+from collections.abc import Iterable
+from IPython import display
+from IPython.display import Markdown
+
+# ----------------------- define instructions -----------------------
+system_instruction = """You are a library chatbot that help people to find relevant articles about a topic, or find a specific article with given title and authors.
+Your job is to analyze the user question, generate enough parameters based on the user question and use the tools that are given to you.
+Also, after the function call is done, you must post-process the results in a more conversational form, providing some explanation about the paper based on its summary to avoid recitation.
+You must provide the link to its Arxiv pdf page."""
+
+# --------------------------- define tools --------------------------
+def search_for_relevant_article(keywords: list['str'], topic_description: str) -> str:
+    """This tool is used to search for articles from the database which is relevant to a topic, using a list of more than 3 keywords and a long sentence topic description.
+    If there is not enough 3 keywords from the question, the model must generate more keywords related to the topic.
+    If there is no description about the topic, the model must generate a description for the function call.
+    \nThe result is a string describe the records found from the database: 'Record no. - Title: <title>, Author: <authors>, Link: <link to the pdf file>, Summary: <summary of the article>'. There can be many records.
+    \nIf the result is 'Information not found' it means some error has occured, or the database has no relevant article"""
+
+    print('Keywords: {}, description: {}'.format(keywords,topic_description))
+    
+    results = utils.ArxivChroma.query_relevant(keywords=keywords, query_texts=topic_description)
+    # print(results)
+    ids = results['metadatas'][0]
+    if len(ids) == 0:
+        # go crawl some
+        new_records = utils.crawl_arxiv(keyword_list=keywords, max_results=10)
+        # print("Got new records: ",len(new_records))
+        if type(new_records) == str:
+            return "Information not found"
+        
+        utils.ArxivChroma.add(new_records)
+        utils.ArxivSQL.add(new_records)
+        results = utils.ArxivChroma.query_relevant(keywords=keywords, query_texts=topic_description)
+        ids = results['metadatas'][0]
+        # print("Re-queried on chromadb, results: ",ids)
+        
+    paper_id = [id['paper_id'] for id in ids]
+    paper_info = utils.ArxivSQL.query_id(paper_id)
+    # print(paper_info)
+    records = [] # get title (2), author (3), link (6)
+    result_string = ""
+    if paper_info:
+        for i in range(len(paper_info)):
+            result_string += "Record no.{} - Title: {}, Author: {}, Link: {}, ".format(i+1,paper_info[i][2],paper_info[i][3],paper_info[i][6])
+            id = paper_info[i][0]
+            selected_document = utils.ArxivChroma.query_exact(id)["documents"]
+            doc_str = "Summary:"
+            for doc in selected_document:
+                doc_str+= doc + " "
+            result_string += doc_str
+            records.append([paper_info[i][2],paper_info[i][3],paper_info[i][6]])
+        return result_string
+    else:
+        return "Information not found"
+
+def search_for_specific_article(title: str, authors: list['str']) -> str:
+    """This tool is used to search for a specific article from the database, with its name and authors given.
+    \nThe result is a string describe the records found from the database: 'Record no. - Title: <title>, Author: <authors>, Link: <link to the pdf file>, Summary: <summary of the article>'. There can be many records.
+    \nIf the result is 'Information not found' it means some error has occured, or the database has no relevant article"""
+
+    print('Keywords: {}, description: {}'.format(title,authors))
+
+    paper_info = utils.ArxivSQL.query(title = title,author = authors)
+    if len(paper_info) == 0:
+        new_records = utils.crawl_exact_paper(title=title,author=authors)
+        # print("Got new records: ",len(new_records))
+        if type(new_records) == str:
+            # print(new_records)
+            return "Information not found"
+        utils.ArxivChroma.add(new_records)
+        utils.ArxivSQL.add(new_records)
+        paper_info = utils.ArxivSQL.query(title = title,author = authors)
+        # print("Re-queried on chromadb, results: ",paper_info)
+    # -------------------------------------
+    records = [] # get title (2), author (3), link (6)
+    result_string = ""
+    if paper_info:
+            for i in range(len(paper_info)):
+                result_string += "Record no.{} - Title: {}, Author: {}, Link: {}, ".format(i+1,paper_info[i][2],paper_info[i][3],paper_info[i][6])
+                id = paper_info[i][0]
+                selected_document = utils.ArxivChroma.query_exact(id)["documents"]
+                doc_str = "Summary:"
+                for doc in selected_document:
+                    doc_str+= doc + " "
+                result_string += doc_str
+                records.append([paper_info[i][2],paper_info[i][3],paper_info[i][6]])
+    # process results:
+    if len(result_string) == 0:
+        return "Information not found"
+    return result_string
+
+def answer_others_questions(question: str) -> str:
+    """This tool is the default option for other questions that are not related to article or paper request. The model will response the question with its own answer."""
+    return question
+
+tools = [search_for_relevant_article, search_for_specific_article, answer_others_questions]
+tools_name = ['search_for_relevant_article', 'search_for_specific_article', 'answer_others_questions']
+
+# load key, prepare config ------------------------
+with open("apikey.txt","r") as apikey:
+    key = apikey.readline()
+genai.configure(api_key=key)
+generation_config = {
+  "temperature": 1,
+  "top_p": 1,
+  "top_k": 0,
+  "max_output_tokens": 2048,
+  "response_mime_type": "text/plain",
+}
+safety_settings = [
+    {
+        "category": "HARM_CATEGORY_DANGEROUS",
+        "threshold": "BLOCK_NONE",
+    },
+    {
+        "category": "HARM_CATEGORY_HARASSMENT",
+        "threshold": "BLOCK_NONE",
+    },
+    {
+        "category": "HARM_CATEGORY_HATE_SPEECH",
+        "threshold": "BLOCK_NONE",
+    },
+    {
+        "category": "HARM_CATEGORY_SEXUALLY_EXPLICIT",
+        "threshold": "BLOCK_NONE",
+    },
+    {
+        "category": "HARM_CATEGORY_DANGEROUS_CONTENT",
+        "threshold": "BLOCK_NONE",
+    },
+]
+# this function return a tool_config with mode 'none', 'any', 'auto'
+def tool_config_from_mode(mode: str, fns: Iterable[str] = ()):
+    """Create a tool config with the specified function calling mode."""
+    return content_types.to_tool_config(
+        {"function_calling_config": {"mode": mode, "allowed_function_names": fns}}
+    )
+
+def init_model(mode = "auto"):
+    # return an instance of a model, holding its own ChatSession
+    # every socket session holds its own model
+    # this function must be called upon socket init, also start_chat() to begin chat
+    model = genai.GenerativeModel(model_name="gemini-1.5-pro-latest",
+                                 safety_settings=safety_settings,
+                                 generation_config=generation_config,
+                                 tools=tools,
+                                 tool_config=tool_config_from_mode(mode),
+                                 system_instruction=system_instruction)
+    chat_instance = model.start_chat(enable_automatic_function_calling=True)
+    return model, chat_instance
+
+# handle tool call and chatsession
+def full_chain_history_question(user_input, chat_instance: genai.ChatSession, mode="auto"):
+    try:            
+        response = chat_instance.send_message(user_input,tool_config=tool_config_from_mode(mode)).text
+        return response, chat_instance.history
+    except Exception as e:
+        print(e)
+        return f'Error occured during call: {e}', chat_instance.history
+
+# for printing log session
+def print_history(history):
+    for content in history:
+        part = content.parts[0]
+        print(content.role, "->", type(part).to_dict(part))
+        print('-'*80)
+
+utils.ArxivChroma.connect()
+utils.ArxivSQL.connect()