chat_with_paper_update

README.md

@@ -5,7 +5,7 @@ emoji: ⚡
 colorFrom: red
 colorTo: purple
 sdk: gradio
-sdk_version: 5.6.0
+sdk_version: 5.8.0
 app_file: app.py
 pinned: false
 header: mini

app.py

@@ -82,6 +82,12 @@ with gr.Blocks(css_paths="style.css") as demo:
                       link="https://huggingface.co/datasets/huggingface/paper-central-data")
 
     with gr.Tabs() as tabs:
+        with gr.Tab("Chat With Paper", id="tab-chat-with-paper", visible=True) as tab_chat_paper:
+            gr.Markdown("## Chat with Paper")
+            arxiv_id = gr.State(value=None)
+            paper_from = gr.State(value=None)
+            paper_chat_tab(arxiv_id, paper_from, paper_central_df)
+
         with gr.Tab("Paper-central", id="tab-paper-central"):
             # Create a row for navigation buttons and calendar
             with gr.Row():
@@ -178,6 +184,8 @@ with gr.Blocks(css_paths="style.css") as demo:
                 wrap=True,
             )
 
+
+
         with gr.Tab("Edit papers", id="tab-pr"):
             pr_paper_central_tab(paper_central_df.df_raw)
 
@@ -187,19 +195,13 @@ with gr.Blocks(css_paths="style.css") as demo:
             with gr.Tab("Contributors"):
                 author_resource_leaderboard_tab()
 
-        with gr.Tab("Chat With Paper", id="tab-chat-with-paper", visible=False) as tab_chat_paper:
-            gr.Markdown("## Chat with Paper")
-            arxiv_id = gr.State(value=None)
-            paper_from = gr.State(value=None)
-            paper_chat_tab(arxiv_id, paper_from)
-
 
     # chat with paper
     def get_selected(evt: gr.SelectData, dataframe_origin):
 
         paper_id = gr.update(value=None)
         paper_from = gr.update(value=None)
-        tab_chat_paper = gr.update(visible=False)
+        tab_chat_paper = gr.update(visible=True)
         selected_tab = gr.Tabs()
 
         try:
@@ -516,7 +518,7 @@ with gr.Blocks(css_paths="style.css") as demo:
         selected_tab = gr.Tabs()
         paper_id = gr.update(value=None)
         paper_from = gr.update(value=None)
-        tab_chat_paper = gr.update(visible=False)
+        tab_chat_paper = gr.update(visible=True)
 
         if request:
             # print("Request headers dictionary:", dict(request.headers))
@@ -568,7 +570,8 @@ with gr.Blocks(css_paths="style.css") as demo:
         api_name="update_data",
     ).then(
         fn=echo,
-        outputs=[calendar, date_range_radio, conference_options, hf_options, tabs, arxiv_id, paper_from, tab_chat_paper],
+        outputs=[calendar, date_range_radio, conference_options, hf_options, tabs, arxiv_id, paper_from,
+                 tab_chat_paper],
         api_name=False,
     ).then(
         # New then to handle LoginButton and HTML components
@@ -583,7 +586,7 @@ def main():
     """
     Launches the Gradio app.
     """
-    demo.launch(ssr_mode=False)
+    demo.launch(share=True)
 
 
 # Run the main function when the script is executed

paper_chat_tab.py

@@ -7,9 +7,10 @@ import requests
 from io import BytesIO
 from transformers import AutoTokenizer
 import json
-
+from datetime import datetime
 import os
 from openai import OpenAI
+import re
 
 # Cache for tokenizers to avoid reloading
 tokenizer_cache = {}
@@ -23,7 +24,6 @@ PROVIDERS = {
         "api_key_env_var": "SAMBANOVA_API_KEY",
         "models": [
             "Meta-Llama-3.1-70B-Instruct",
-            # Add more models if needed
         ],
         "type": "tuples",
         "max_total_tokens": "50000",
@@ -43,12 +43,12 @@ PROVIDERS = {
 }
 
 
-# Function to fetch paper information from OpenReview
+# Functions for paper fetching
 def fetch_paper_info_neurips(paper_id):
     url = f"https://openreview.net/forum?id={paper_id}"
     response = requests.get(url)
     if response.status_code != 200:
-        return None
+        return None, None, None
 
     html_content = response.content
     soup = BeautifulSoup(html_content, 'html.parser')
@@ -73,66 +73,104 @@ def fetch_paper_info_neurips(paper_id):
     else:
         abstract = 'Abstract not found'
 
-    # Construct preamble in Markdown
-    preamble = f"**[{title}](https://openreview.net/forum?id={paper_id})**\n\n{author_list}\n\n"
+    # Construct preamble
+    link = f"https://openreview.net/forum?id={paper_id}"
+    return title, author_list, f"**Abstract:** {abstract}\n\n[View on OpenReview]({link})"
 
-    return preamble
 
-
-def fetch_paper_content_arxiv(paper_id):
+def fetch_paper_content_neurips(paper_id):
     try:
-        # Construct the URL for the arXiv PDF
-        url = f"https://arxiv.org/pdf/{paper_id}.pdf"
-
-        # Fetch the PDF
+        url = f"https://openreview.net/pdf?id={paper_id}"
         response = requests.get(url)
-        response.raise_for_status()  # Raise an exception for HTTP errors
-
-        # Read the PDF content
+        response.raise_for_status()
         pdf_content = BytesIO(response.content)
         reader = PdfReader(pdf_content)
-
-        # Extract text from the PDF
         text = ""
         for page in reader.pages:
             text += page.extract_text()
-
-        return text  # Return full text; truncation will be handled later
-    except Exception as e:
-        print(f"Error fetching paper content: {e}")
+        return text
+    except:
         return None
 
 
-def fetch_paper_content(paper_id):
+def fetch_paper_content_arxiv(paper_id):
     try:
-        # Construct the URL
-        url = f"https://openreview.net/pdf?id={paper_id}"
-
-        # Fetch the PDF
+        url = f"https://arxiv.org/pdf/{paper_id}.pdf"
         response = requests.get(url)
-        response.raise_for_status()  # Raise an exception for HTTP errors
-
-        # Read the PDF content
+        response.raise_for_status()
         pdf_content = BytesIO(response.content)
         reader = PdfReader(pdf_content)
-
-        # Extract text from the PDF
         text = ""
         for page in reader.pages:
             text += page.extract_text()
-
-        return text  # Return full text; truncation will be handled later
-
+        return text
     except Exception as e:
-        print(f"An error occurred: {e}")
+        print(f"Error fetching paper content: {e}")
         return None
 
 
+def fetch_paper_info_paperpage(paper_id_value):
+    # Extract paper_id from paper_page link or input
+    def extract_paper_id(input_string):
+        # Already in correct form?
+        if re.fullmatch(r'\d+\.\d+', input_string.strip()):
+            return input_string.strip()
+        # If URL
+        match = re.search(r'https://huggingface\.co/papers/(\d+\.\d+)', input_string)
+        if match:
+            return match.group(1)
+        return input_string.strip()
+
+    paper_id_value = extract_paper_id(paper_id_value)
+    url = f"https://huggingface.co/api/papers/{paper_id_value}?field=comments"
+    response = requests.get(url)
+    if response.status_code != 200:
+        return None, None, None
+    paper_info = response.json()
+    title = paper_info.get('title', 'No Title')
+    authors_list = [author.get('name', 'Unknown') for author in paper_info.get('authors', [])]
+    authors = ', '.join(authors_list)
+    summary = paper_info.get('summary', 'No Summary')
+    num_comments = len(paper_info.get('comments', []))
+    num_upvotes = paper_info.get('upvotes', 0)
+    link = f"https://huggingface.co/papers/{paper_id_value}"
+
+    details = f"{summary}<br/>👍{num_comments} 💬{num_upvotes}<br/> <a href='{link}' " \
+              f"target='_blank'>View on 🤗 hugging face</a>"
+    return title, authors, details
+
+
+def fetch_paper_content_paperpage(paper_id_value):
+    # Extract paper_id
+    def extract_paper_id(input_string):
+        if re.fullmatch(r'\d+\.\d+', input_string.strip()):
+            return input_string.strip()
+        match = re.search(r'https://huggingface\.co/papers/(\d+\.\d+)', input_string)
+        if match:
+            return match.group(1)
+        return input_string.strip()
+
+    paper_id_value = extract_paper_id(paper_id_value)
+    text = fetch_paper_content_arxiv(paper_id_value)
+    return text
+
+
+# Dictionary for paper sources
+PAPER_SOURCES = {
+    "neurips": {
+        "fetch_info": fetch_paper_info_neurips,
+        "fetch_pdf": fetch_paper_content_neurips
+    },
+    "paper_page": {
+        "fetch_info": fetch_paper_info_paperpage,
+        "fetch_pdf": fetch_paper_content_paperpage
+    }
+}
+
+
 def create_chat_interface(provider_dropdown, model_dropdown, paper_content, hf_token_input, default_type,
                           provider_max_total_tokens):
     # Define the function to handle the chat
-    print("the type is", default_type.value)
-
     def get_fn(message, history, paper_content_value, hf_token_value, provider_name_value, model_name_value,
                max_total_tokens):
         provider_info = PROVIDERS[provider_name_value]
@@ -141,11 +179,9 @@ def create_chat_interface(provider_dropdown, model_dropdown, paper_content, hf_t
         models = provider_info['models']
         max_total_tokens = int(max_total_tokens)
 
-        # Load tokenizer and cache it
+        # Load tokenizer
         tokenizer_key = f"{provider_name_value}_{model_name_value}"
         if tokenizer_key not in tokenizer_cache:
-            # Load the tokenizer; adjust the model path based on the provider and model
-            # This is a placeholder; you need to provide the correct tokenizer path
             tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-3.2-1B-Instruct",
                                                       token=os.environ.get("HF_TOKEN"))
             tokenizer_cache[tokenizer_key] = tokenizer
@@ -189,32 +225,28 @@ def create_chat_interface(provider_dropdown, model_dropdown, paper_content, hf_t
 
         # Check if total tokens exceed the maximum allowed tokens
         if total_tokens > max_total_tokens:
-            # Attempt to truncate the context first
+            # Attempt to truncate context
             available_tokens = max_total_tokens - (total_tokens - context_token_length)
             if available_tokens > 0:
-                # Truncate the context to fit the available tokens
                 truncated_context_tokens = context_tokens[:available_tokens]
                 context = tokenizer.decode(truncated_context_tokens)
                 context_token_length = available_tokens
                 total_tokens = total_tokens - len(context_tokens) + context_token_length
             else:
-                # Not enough space for context; remove it
                 context = ""
                 total_tokens -= context_token_length
                 context_token_length = 0
 
-        # If total tokens still exceed the limit, truncate the message history
+        # Truncate message history if needed
         while total_tokens > max_total_tokens and len(messages) > 1:
-            # Remove the oldest message
             removed_message = messages.pop(0)
             removed_tokens = message_tokens_list.pop(0)
             total_tokens -= removed_tokens
 
-        # Rebuild the final messages list including the (possibly truncated) context
+        # Rebuild the final messages
         final_messages = []
         if context:
-            final_messages.append(
-                {"role": "system", "content": f"{context}"})
+            final_messages.append({"role": "system", "content": f"{context}"})
         final_messages.extend(messages)
 
         # Use the provider's API key
@@ -222,14 +254,13 @@ def create_chat_interface(provider_dropdown, model_dropdown, paper_content, hf_t
         if not api_key:
             raise ValueError("API token is not provided.")
 
-        # Initialize the OpenAI client with the provider's endpoint
+        # Initialize the OpenAI client
         client = OpenAI(
             base_url=endpoint,
             api_key=api_key,
         )
 
         try:
-            # Create the chat completion
             completion = client.chat.completions.create(
                 model=model_name_value,
                 messages=final_messages,
@@ -241,29 +272,13 @@ def create_chat_interface(provider_dropdown, model_dropdown, paper_content, hf_t
                 response_text += delta
                 yield response_text
         except json.JSONDecodeError as e:
-            print("Failed to decode JSON during the completion creation process.")
-            print(f"Error Message: {e.msg}")
-            print(f"Error Position: Line {e.lineno}, Column {e.colno} (Character {e.pos})")
-            print(f"Problematic JSON Data: {e.doc}")
-            yield f"{e.doc}"
+            yield f"JSON decoding error: {e.msg}"
         except openai.OpenAIError as openai_err:
-            # Handle other OpenAI-related errors
-            print(f"An OpenAI error occurred: {openai_err}")
-            yield f"{openai_err}"
+            yield f"OpenAI error: {openai_err}"
         except Exception as ex:
-            # Handle any other exceptions
-            print(f"An unexpected error occurred: {ex}")
-            yield f"{ex}"
-
-    # Create the Chatbot separately to access it later
-    chatbot = gr.Chatbot(
-        label="Chatbot",
-        scale=1,
-        height=400,
-        autoscroll=True,
-    )
+            yield f"Unexpected error: {ex}"
 
-    # Create the ChatInterface
+    chatbot = gr.Chatbot(label="Chatbot", scale=1, height=400, autoscroll=True)
     chat_interface = gr.ChatInterface(
         fn=get_fn,
         chatbot=chatbot,
@@ -273,142 +288,164 @@ def create_chat_interface(provider_dropdown, model_dropdown, paper_content, hf_t
     return chat_interface, chatbot
 
 
-def paper_chat_tab(paper_id, paper_from):
-    with gr.Column():
-
-        # Preamble message to hint the user
-        gr.Markdown("**Note:** Providing your own API token can help you avoid rate limits.")
+def paper_chat_tab(paper_id, paper_from, paper_central_df):
+    with gr.Row():
+        # Left column: Paper selection and display
+        with gr.Column(scale=1):
+            gr.Markdown("### Select a Paper")
+            todays_date = datetime.today().strftime('%Y-%m-%d')
 
-        # Input for API token
-        provider_names = list(PROVIDERS.keys())
-        default_provider = provider_names[0]
+            # Filter papers for today's date and having a paper_page
+            selectable_papers = paper_central_df.df_prettified
+            selectable_papers = selectable_papers[
+                selectable_papers['paper_page'].notna() &
+                (selectable_papers['paper_page'] != "") &
+                (selectable_papers['date'] == todays_date)
+                ]
 
-        default_type = gr.State(value=PROVIDERS[default_provider]["type"])
-        default_max_total_tokens = gr.State(value=PROVIDERS[default_provider]["max_total_tokens"])
+            paper_choices = [(row['title'], row['paper_page']) for _, row in selectable_papers.iterrows()]
+            paper_choices = sorted(paper_choices, key=lambda x: x[0])
 
-        provider_dropdown = gr.Dropdown(
-            label="Select Provider",
-            choices=provider_names,
-            value=default_provider
-        )
+            if not paper_choices:
+                paper_choices = [("No available papers for today", "")]
 
-        hf_token_input = gr.Textbox(
-            label=f"Enter your {default_provider} API token (optional)",
-            type="password",
-            placeholder=f"Enter your {default_provider} API token to avoid rate limits"
-        )
-
-        # Dropdown for selecting the model
-        model_dropdown = gr.Dropdown(
-            label="Select Model",
-            choices=PROVIDERS[default_provider]['models'],
-            value=PROVIDERS[default_provider]['models'][0]
-        )
+            paper_select = gr.Dropdown(
+                label="Select a paper to chat with:",
+                choices=[p[0] for p in paper_choices],
+                value=paper_choices[0][0] if paper_choices else None
+            )
+            select_paper_button = gr.Button("Load this paper")
 
-        # Placeholder for the provider logo
-        logo_html = gr.HTML(
-            value=f'<img src="{PROVIDERS[default_provider]["logo"]}" width="100px" />'
-        )
+            # Paper info display - styled card
+            content = gr.HTML(value="", elem_id="paper_info_card")
 
-        # Note about the provider
-        note_markdown = gr.Markdown(f"**Note:** This model is supported by {default_provider}.")
+        # Right column: Provider and model selection + chat
+        with gr.Column(scale=1, visible=False) as provider_section:
+            gr.Markdown("### LLM Provider and Model")
+            provider_names = list(PROVIDERS.keys())
+            default_provider = provider_names[0]
 
-        # State to store the paper content
-        paper_content = gr.State()
+            default_type = gr.State(value=PROVIDERS[default_provider]["type"])
+            default_max_total_tokens = gr.State(value=PROVIDERS[default_provider]["max_total_tokens"])
 
-        # Textbox to display the paper title and authors
-        content = gr.Markdown(value="")
+            provider_dropdown = gr.Dropdown(
+                label="Select Provider",
+                choices=provider_names,
+                value=default_provider
+            )
 
-        # Create the chat interface and get the chatbot component
-        chat_interface, chatbot = create_chat_interface(provider_dropdown, model_dropdown, paper_content,
-                                                        hf_token_input,
-                                                        default_type, default_max_total_tokens)
+            hf_token_input = gr.Textbox(
+                label=f"Enter your {default_provider} API token (optional)",
+                type="password",
+                placeholder=f"Enter your {default_provider} API token to avoid rate limits"
+            )
 
-        # Function to update models and logo when provider changes
-        def update_provider(selected_provider):
-            provider_info = PROVIDERS[selected_provider]
-            models = provider_info['models']
-            logo_url = provider_info['logo']
-            chatbot_message_type = provider_info['type']
-            max_total_tokens = provider_info['max_total_tokens']
+            model_dropdown = gr.Dropdown(
+                label="Select Model",
+                choices=PROVIDERS[default_provider]['models'],
+                value=PROVIDERS[default_provider]['models'][0]
+            )
 
-            # Update the models dropdown
-            model_dropdown_choices = gr.update(choices=models, value=models[0])
+            logo_html = gr.HTML(
+                value=f'<img src="{PROVIDERS[default_provider]["logo"]}" width="100px" />'
+            )
 
-            # Update the logo image
-            logo_html_content = f'<img src="{logo_url}" width="100px" />'
-            logo_html_update = gr.update(value=logo_html_content)
+            note_markdown = gr.Markdown(f"**Note:** This model is supported by {default_provider}.")
 
-            # Update the note markdown
-            note_markdown_update = gr.update(value=f"**Note:** This model is supported by {selected_provider}.")
+            paper_content = gr.State()
 
-            # Update the hf_token_input label and placeholder
-            hf_token_input_update = gr.update(
-                label=f"Enter your {selected_provider} API token (optional)",
-                placeholder=f"Enter your {selected_provider} API token to avoid rate limits"
-            )
+            # Create chat interface
+            chat_interface, chatbot = create_chat_interface(provider_dropdown, model_dropdown, paper_content,
+                                                            hf_token_input, default_type, default_max_total_tokens)
 
-            # Reset the chatbot history
-            chatbot_reset = []  # This resets the chatbot conversation
+    def update_provider(selected_provider):
+        provider_info = PROVIDERS[selected_provider]
+        models = provider_info['models']
+        logo_url = provider_info['logo']
+        chatbot_message_type = provider_info['type']
+        max_total_tokens = provider_info['max_total_tokens']
+
+        model_dropdown_choices = gr.update(choices=models, value=models[0])
+        logo_html_content = f'<img src="{logo_url}" width="100px" />'
+        logo_html_update = gr.update(value=logo_html_content)
+        note_markdown_update = gr.update(value=f"**Note:** This model is supported by {selected_provider}.")
+        hf_token_input_update = gr.update(
+            label=f"Enter your {selected_provider} API token (optional)",
+            placeholder=f"Enter your {selected_provider} API token to avoid rate limits"
+        )
+        chatbot_reset = []
+        return model_dropdown_choices, logo_html_update, note_markdown_update, hf_token_input_update, chatbot_message_type, max_total_tokens, chatbot_reset
+
+    provider_dropdown.change(
+        fn=update_provider,
+        inputs=provider_dropdown,
+        outputs=[model_dropdown, logo_html, note_markdown, hf_token_input, default_type, default_max_total_tokens,
+                 chatbot],
+        queue=False
+    )
 
-            return model_dropdown_choices, logo_html_update, note_markdown_update, hf_token_input_update, chatbot_message_type, max_total_tokens, chatbot_reset
+    def update_paper_info(paper_id_value, paper_from_value, selected_model, old_content):
+        # Use PAPER_SOURCES to fetch info
+        source_info = PAPER_SOURCES.get(paper_from_value, {})
+        fetch_info_fn = source_info.get("fetch_info")
+        fetch_pdf_fn = source_info.get("fetch_pdf")
+
+        if not fetch_info_fn or not fetch_pdf_fn:
+            return gr.update(value="<div>No information available.</div>"), None, []
+
+        title, authors, details = fetch_info_fn(paper_id_value)
+        if title is None and authors is None and details is None:
+            return gr.update(value="<div>No information could be retrieved.</div>"), None, []
+
+        text = fetch_pdf_fn(paper_id_value)
+        if text is None:
+            text = "Paper content could not be retrieved."
+
+        # Create a styled card for the paper info
+        card_html = f"""
+        <div style="border:1px solid #ccc; border-radius:6px; background:#f9f9f9; padding:15px; margin-bottom:10px;">
+            <center><h3 style="margin-top:0; text-decoration:underline;">You are talking with:</h3></center>
+            <h3>{title}</h3>
+            <p><strong>Authors:</strong> {authors}</p>
+            <p>{details}</p>
+        </div>
+        """
+
+        return gr.update(value=card_html), text, []
+
+    def select_paper(paper_title):
+        # Find the corresponding paper_page from the title
+        for t, ppage in paper_choices:
+            if t == paper_title:
+                return ppage, "paper_page"
+        return "", ""
+
+    select_paper_button.click(
+        fn=select_paper,
+        inputs=[paper_select],
+        outputs=[paper_id, paper_from]
+    )
 
-        provider_dropdown.change(
-            fn=update_provider,
-            inputs=provider_dropdown,
-            outputs=[model_dropdown, logo_html, note_markdown, hf_token_input, default_type, default_max_total_tokens,
-                     chatbot],
-            queue=False
-        )
+    # After updating paper_id, we update paper info
+    paper_id.change(
+        fn=update_paper_info,
+        inputs=[paper_id, paper_from, model_dropdown, content],
+        outputs=[content, paper_content, chatbot]
+    )
 
-        # Function to update the paper info
-        def update_paper_info(paper_id_value, paper_from_value, selected_model):
-            if paper_from_value == "neurips":
-                preamble = fetch_paper_info_neurips(paper_id_value)
-                text = fetch_paper_content(paper_id_value)
-                if preamble is None:
-                    preamble = "Paper not found or could not retrieve paper information."
-                if text is None:
-                    return preamble, None, []
-                return preamble, text, []
-            elif paper_from_value == "paper_page":
-                # Fetch the paper information from Hugging Face API
-                url = f"https://huggingface.co/api/papers/{paper_id_value}?field=comments"
-                response = requests.get(url)
-                if response.status_code != 200:
-                    return "Paper not found or could not retrieve paper information.", None, []
-                paper_info = response.json()
-
-                # Extract required information
-                title = paper_info.get('title', 'No Title')
-                link = f"https://huggingface.co/papers/{paper_id_value}"
-                authors_list = [author.get('name', 'Unknown') for author in paper_info.get('authors', [])]
-                authors = ', '.join(authors_list)
-                summary = paper_info.get('summary', 'No Summary')
-                num_comments = len(paper_info.get('comments', []))
-                num_upvotes = paper_info.get('upvotes', 0)
-
-                # Format the preamble
-                preamble = f"🤗 [paper-page]({link})<br/>"
-                preamble += f"**Title:** {title}<br/>"
-                preamble += f"**Authors:** {authors}<br/>"
-                preamble += f"**Summary:**<br/>>\n{summary}<br/>"
-                preamble += f"👍{num_comments} 💬{num_upvotes} <br/>"
-
-                # Fetch the paper content
-                text = fetch_paper_content_arxiv(paper_id_value)
-                if text is None:
-                    text = "Paper content could not be retrieved."
-                return preamble, text, []
-            else:
-                return "", "", []
+    # Function to toggle visibility of the right column based on paper_id
+    def toggle_provider_visibility(paper_id_value):
+        if paper_id_value and paper_id_value.strip():
+            return gr.update(visible=True)
+        else:
+            return gr.update(visible=False)
 
-        # Update paper content when paper ID changes
-        paper_id.change(
-            fn=update_paper_info,
-            inputs=[paper_id, paper_from, model_dropdown],
-            outputs=[content, paper_content, chatbot]
-        )
+    # Chain a then call to toggle visibility of the provider_section after paper info update
+    paper_id.change(
+        fn=toggle_provider_visibility,
+        inputs=[paper_id],
+        outputs=[provider_section]
+    )
 
 
 def main():
@@ -416,10 +453,7 @@ def main():
     Launches the Gradio app.
     """
     with gr.Blocks(css_paths="style.css") as demo:
-        # Create an input for paper_id
         paper_id = gr.Textbox(label="Paper ID", value="")
-
-        # Create an input for paper_from (e.g., 'neurips' or 'paper_page')
         paper_from = gr.Radio(
             label="Paper Source",
             choices=["neurips", "paper_page"],
@@ -427,11 +461,24 @@ def main():
         )
 
         # Build the paper chat tab
-        paper_chat_tab(paper_id, paper_from)
+        dummy_calendar = gr.State(datetime.now().strftime("%Y-%m-%d"))
+
+        class MockPaperCentral:
+            def __init__(self):
+                import pandas as pd
+                data = {
+                    'date': [datetime.today().strftime('%Y-%m-%d')],
+                    'paper_page': ['1234.56789'],
+                    'title': ['An Example Paper']
+                }
+                self.df_prettified = pd.DataFrame(data)
+
+        paper_central_df = MockPaperCentral()
+
+        paper_chat_tab(paper_id, paper_from, paper_central_df)
 
     demo.launch(ssr_mode=False)
 
 
-# Run the main function when the script is executed
 if __name__ == "__main__":
     main()