aiagents4pharma 1.30.0__py3-none-any.whl → 1.30.2__py3-none-any.whl

aiagents4pharma/talk2scholars/tools/paper_download/abstract_downloader.py

@@ -9,6 +9,8 @@ inherit from this class and implement its methods.
 
 from abc import ABC, abstractmethod
 from typing import Any, Dict
+
+
 class AbstractPaperDownloader(ABC):
     """
     Abstract base class for scholarly paper downloaders.

aiagents4pharma/talk2scholars/tools/paper_download/arxiv_downloader.py

@@ -8,6 +8,7 @@ downloads the corresponding PDF.
 By using an abstract base class, this implementation is extendable to other
 APIs like PubMed, IEEE Xplore, etc.
 """
+
 import xml.etree.ElementTree as ET
 from typing import Any, Dict
 import logging
@@ -19,6 +20,7 @@ from .abstract_downloader import AbstractPaperDownloader
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
+
 class ArxivPaperDownloader(AbstractPaperDownloader):
     """
     Downloader class for arXiv.
@@ -35,13 +37,13 @@ class ArxivPaperDownloader(AbstractPaperDownloader):
         """
         with hydra.initialize(version_base=None, config_path="../../configs"):
             cfg = hydra.compose(
-                config_name="config",
-                overrides=["tools/download_arxiv_paper=default"]
+                config_name="config", overrides=["tools/download_arxiv_paper=default"]
             )
             self.api_url = cfg.tools.download_arxiv_paper.api_url
             self.request_timeout = cfg.tools.download_arxiv_paper.request_timeout
             self.chunk_size = cfg.tools.download_arxiv_paper.chunk_size
             self.pdf_base_url = cfg.tools.download_arxiv_paper.pdf_base_url
+
     def fetch_metadata(self, paper_id: str) -> Dict[str, Any]:
         """
         Fetch metadata from arXiv for a given paper ID.
@@ -95,11 +97,16 @@ class ArxivPaperDownloader(AbstractPaperDownloader):
         logger.info("Downloading PDF from: %s", pdf_url)
         pdf_response = requests.get(pdf_url, stream=True, timeout=self.request_timeout)
         pdf_response.raise_for_status()
+        # print (pdf_response)
 
         # Combine the PDF data from chunks.
         pdf_object = b"".join(
-            chunk for chunk in pdf_response.iter_content(chunk_size=self.chunk_size) if chunk
-            )
+            chunk
+            for chunk in pdf_response.iter_content(chunk_size=self.chunk_size)
+            if chunk
+        )
+        # print (pdf_object)
+        print("PDF_URL", pdf_url)
 
         return {
             "pdf_object": pdf_object,

aiagents4pharma/talk2scholars/tools/paper_download/download_arxiv_input.py

@@ -14,16 +14,19 @@ from langgraph.types import Command
 # Local import from the same package:
 from .arxiv_downloader import ArxivPaperDownloader
 
+
 class DownloadArxivPaperInput(BaseModel):
     """
     Input schema for the arXiv paper download tool.
     (Optional: if you decide to keep Pydantic validation in the future)
     """
+
     arxiv_id: str = Field(
         description="The arXiv paper ID used to retrieve the paper details and PDF."
-        )
+    )
     tool_call_id: Annotated[str, InjectedToolCallId]
 
+
 @tool(args_schema=DownloadArxivPaperInput, parse_docstring=True)
 def download_arxiv_paper(
     arxiv_id: str,
@@ -49,6 +52,7 @@ def download_arxiv_paper(
 
     # If the downloader fails or the arxiv_id is invalid, this might raise an error
     pdf_data = downloader.download_pdf(arxiv_id)
+    # print (pdf_data)
 
     content = f"Successfully downloaded PDF for arXiv ID {arxiv_id}"
 

aiagents4pharma/talk2scholars/tools/pdf/question_and_answer.py

@@ -2,8 +2,8 @@
 """
 question_and_answer: Tool for performing Q&A on PDF documents using retrieval augmented generation.
 
-This module provides functionality to extract text from PDF binary data, split it into 
-chunks, retrieve relevant segments via a vector store, and generate an answer to a 
+This module provides functionality to extract text from PDF binary data, split it into
+chunks, retrieve relevant segments via a vector store, and generate an answer to a
 user-provided question using a language model chain.
 """
 
@@ -18,13 +18,15 @@ import hydra
 from langchain.chains.question_answering import load_qa_chain
 from langchain.docstore.document import Document
 from langchain.text_splitter import CharacterTextSplitter
-from langchain_community.vectorstores import Annoy
-from langchain_openai import OpenAIEmbeddings
 from langchain_core.language_models.chat_models import BaseChatModel
-
+from langchain_core.vectorstores import InMemoryVectorStore
 from langchain_core.messages import ToolMessage
 from langchain_core.tools import tool
 from langchain_core.tools.base import InjectedToolCallId
+from langchain_core.embeddings import Embeddings
+from langchain_community.vectorstores import Annoy
+from langchain_community.document_loaders import PyPDFLoader
+from langchain_openai import OpenAIEmbeddings
 from langgraph.types import Command
 from langgraph.prebuilt import InjectedState
 
@@ -35,10 +37,13 @@ logger.setLevel(logging.INFO)
 
 # Load configuration using Hydra.
 with hydra.initialize(version_base=None, config_path="../../configs"):
-    cfg = hydra.compose(config_name="config", overrides=["tools/question_and_answer=default"])
+    cfg = hydra.compose(
+        config_name="config", overrides=["tools/question_and_answer=default"]
+    )
     cfg = cfg.tools.question_and_answer
     logger.info("Loaded Question and Answer tool configuration.")
 
+
 class QuestionAndAnswerInput(BaseModel):
     """
     Input schema for the PDF Question and Answer tool.
@@ -47,12 +52,12 @@ class QuestionAndAnswerInput(BaseModel):
         question (str): The question to ask regarding the PDF content.
         tool_call_id (str): Unique identifier for the tool call, injected automatically.
     """
-    question: str = Field(
-        description="The question to ask regarding the PDF content."
-    )
+
+    question: str = Field(description="The question to ask regarding the PDF content.")
     tool_call_id: Annotated[str, InjectedToolCallId]
     state: Annotated[dict, InjectedState]
 
+
 def extract_text_from_pdf_data(pdf_bytes: bytes) -> str:
     """
     Extract text content from PDF binary data.
@@ -73,7 +78,10 @@ def extract_text_from_pdf_data(pdf_bytes: bytes) -> str:
         text += page_text
     return text
 
-def generate_answer(question: str, pdf_bytes: bytes, llm_model: BaseChatModel) -> Dict[str, Any]:
+
+def generate_answer(
+    question: str, pdf_bytes: bytes, llm_model: BaseChatModel
+) -> Dict[str, Any]:
     """
     Generate an answer for a question using retrieval augmented generation on PDF content.
 
@@ -92,9 +100,7 @@ def generate_answer(question: str, pdf_bytes: bytes, llm_model: BaseChatModel) -
     text = extract_text_from_pdf_data(pdf_bytes)
     logger.info("Extracted text from PDF.")
     text_splitter = CharacterTextSplitter(
-        separator="\n",
-        chunk_size=cfg.chunk_size,
-        chunk_overlap=cfg.chunk_overlap
+        separator="\n", chunk_size=cfg.chunk_size, chunk_overlap=cfg.chunk_overlap
     )
     chunks = text_splitter.split_text(text)
     documents: List[Document] = [Document(page_content=chunk) for chunk in chunks]
@@ -102,10 +108,7 @@ def generate_answer(question: str, pdf_bytes: bytes, llm_model: BaseChatModel) -
 
     embeddings = OpenAIEmbeddings(openai_api_key=cfg.openai_api_key)
     vector_store = Annoy.from_documents(documents, embeddings)
-    search_results = vector_store.similarity_search(
-        question,
-        k=cfg.num_retrievals
-    )
+    search_results = vector_store.similarity_search(question, k=cfg.num_retrievals)
     logger.info("Retrieved %d relevant document chunks.", len(search_results))
     # Use the provided llm_model to build the QA chain.
     qa_chain = load_qa_chain(llm_model, chain_type=cfg.qa_chain_type)
@@ -114,6 +117,49 @@ def generate_answer(question: str, pdf_bytes: bytes, llm_model: BaseChatModel) -
     )
     return answer
 
+
+def generate_answer2(
+    question: str, pdf_url: str, text_embedding_model: Embeddings
+) -> Dict[str, Any]:
+    """
+    Generate an answer for a question using retrieval augmented generation on PDF content.
+
+    This function extracts text from the PDF data, splits the text into manageable chunks,
+    performs a similarity search to retrieve the most relevant segments, and then uses a
+    question-answering chain (built using the provided llm_model) to generate an answer.
+
+    Args:
+        question (str): The question to be answered.
+        pdf_bytes (bytes): The binary content of the PDF document.
+        llm_model (BaseChatModel): The language model instance to use for answering.
+
+    Returns:
+        Dict[str, Any]: A dictionary containing the answer generated by the language model.
+    """
+    # text = extract_text_from_pdf_data(pdf_bytes)
+    # logger.info("Extracted text from PDF.")
+    logger.log(logging.INFO, "searching the article with the question: %s", question)
+    # Load the article
+    # loader = PyPDFLoader(state['pdf_file_name'])
+    # loader = PyPDFLoader("https://arxiv.org/pdf/2310.08365")
+    loader = PyPDFLoader(pdf_url)
+    # Load the pages of the article
+    pages = []
+    for page in loader.lazy_load():
+        pages.append(page)
+    # Set up text embedding model
+    # text_embedding_model = state['text_embedding_model']
+    # text_embedding_model = OpenAIEmbeddings(openai_api_key=cfg.openai_api_key)
+    logging.info("Loaded text embedding model %s", text_embedding_model)
+    # Create a vector store from the pages
+    vector_store = InMemoryVectorStore.from_documents(pages, text_embedding_model)
+    # Search the article with the question
+    docs = vector_store.similarity_search(question)
+    # Return the content of the pages
+    return "\n".join([doc.page_content for doc in docs])
+    # return answer
+
+
 @tool(args_schema=QuestionAndAnswerInput)
 def question_and_answer_tool(
     question: str,
@@ -124,7 +170,7 @@ def question_and_answer_tool(
     Answer a question using PDF content stored in the state via retrieval augmented generation.
 
     This tool retrieves the PDF binary data from the state (under the key "pdf_data"), extracts its
-    textual content, and generates an answer to the specified question. It also extracts the 
+    textual content, and generates an answer to the specified question. It also extracts the
     llm_model (of type BaseChatModel) from the state to use for answering.
 
     Args:
@@ -138,15 +184,15 @@ def question_and_answer_tool(
         Dict[str, Any]: A dictionary containing the generated answer or an error message.
     """
     logger.info("Starting PDF Question and Answer tool using PDF data from state.")
+    # print (state['text_embedding_model'])
+    text_embedding_model = state["text_embedding_model"]
     pdf_state = state.get("pdf_data")
     if not pdf_state:
         error_msg = "No pdf_data found in state."
         logger.error(error_msg)
         return Command(
             update={
-                "messages": [
-                    ToolMessage(content=error_msg, tool_call_id=tool_call_id)
-                ]
+                "messages": [ToolMessage(content=error_msg, tool_call_id=tool_call_id)]
             }
         )
     pdf_bytes = pdf_state.get("pdf_object")
@@ -155,16 +201,17 @@ def question_and_answer_tool(
         logger.error(error_msg)
         return Command(
             update={
-                "messages": [
-                    ToolMessage(content=error_msg, tool_call_id=tool_call_id)
-                ]
+                "messages": [ToolMessage(content=error_msg, tool_call_id=tool_call_id)]
             }
         )
+    pdf_url = pdf_state.get("pdf_url")
     # Retrieve llm_model from state; use a default if not provided.
     llm_model = state.get("llm_model")
     if not llm_model:
         logger.error("Missing LLM model instance in state.")
         return {"error": "No LLM model found in state."}
-    answer = generate_answer(question, pdf_bytes, llm_model)
-    logger.info("Generated answer: %s", answer)
+    # answer = generate_answer(question, pdf_bytes, llm_model)
+    print(pdf_url)
+    answer = generate_answer2(question, pdf_url, text_embedding_model)
+    # logger.info("Generated answer: %s", answer)
     return answer

aiagents4pharma/talk2scholars/tools/s2/multi_paper_rec.py

@@ -30,7 +30,7 @@ class MultiPaperRecInput(BaseModel):
         description="List of Semantic Scholar Paper IDs to get recommendations for"
     )
     limit: int = Field(
-        default=2,
+        default=10,
         description="Maximum total number of recommendations to return",
         ge=1,
         le=500,
@@ -90,23 +90,33 @@ def get_multi_paper_recommendations(
         params["year"] = year
 
     # Wrap API call in try/except to catch connectivity issues and validate response format
-    try:
-        response = requests.post(
-            endpoint,
-            headers=headers,
-            params=params,
-            data=json.dumps(payload),
-            timeout=cfg.request_timeout,
-        )
-        response.raise_for_status()  # Raises HTTPError for bad responses
-    except requests.exceptions.RequestException as e:
-        logger.error(
-            "Failed to connect to Semantic Scholar API for multi-paper recommendations: %s",
-            e,
-        )
-        raise RuntimeError(
-            "Failed to connect to Semantic Scholar API. Please retry the same query."
-        ) from e
+    response = None
+    for attempt in range(10):
+        try:
+            response = requests.post(
+                endpoint,
+                headers=headers,
+                params=params,
+                data=json.dumps(payload),
+                timeout=cfg.request_timeout,
+            )
+            response.raise_for_status()  # Raises HTTPError for bad responses
+            break  # Exit loop if request is successful
+        except requests.exceptions.RequestException as e:
+            logger.error(
+                "Attempt %d: Failed to connect to Semantic Scholar API for "
+                "multi-paper recommendations: %s",
+                attempt + 1,
+                e,
+            )
+            if attempt == 9:  # Last attempt
+                raise RuntimeError(
+                    "Failed to connect to Semantic Scholar API after 10 attempts."
+                    "Please retry the same query."
+                ) from e
+
+    if response is None:
+        raise RuntimeError("Failed to obtain a response from the Semantic Scholar API.")
 
     logger.info(
         "API Response Status for multi-paper recommendations: %s", response.status_code
@@ -137,11 +147,22 @@ def get_multi_paper_recommendations(
     # Create a dictionary to store the papers
     filtered_papers = {
         paper["paperId"]: {
-            "paper_id": paper["paperId"],
+            "semantic_scholar_paper_id": paper["paperId"],
             "Title": paper.get("title", "N/A"),
             "Abstract": paper.get("abstract", "N/A"),
             "Year": paper.get("year", "N/A"),
+            "Publication Date": paper.get("publicationDate", "N/A"),
+            "Venue": paper.get("venue", "N/A"),
+            # "Publication Venue": (paper.get("publicationVenue") or {}).get("name", "N/A"),
+            # "Venue Type": (paper.get("publicationVenue") or {}).get("name", "N/A"),
+            "Journal Name": (paper.get("journal") or {}).get("name", "N/A"),
+            # "Journal Volume": paper.get("journal", {}).get("volume", "N/A"),
+            # "Journal Pages": paper.get("journal", {}).get("pages", "N/A"),
             "Citation Count": paper.get("citationCount", "N/A"),
+            "Authors": [
+                f"{author.get('name', 'N/A')} (ID: {author.get('authorId', 'N/A')})"
+                for author in paper.get("authors", [])
+            ],
             "URL": paper.get("url", "N/A"),
             "arxiv_id": paper.get("externalIds", {}).get("ArXiv", "N/A"),
         }
@@ -153,7 +174,10 @@ def get_multi_paper_recommendations(
     top_papers = list(filtered_papers.values())[:3]
     top_papers_info = "\n".join(
         [
-            f"{i+1}. {paper['Title']} ({paper['Year']})"
+            # f"{i+1}. {paper['Title']} ({paper['Year']})"
+            f"{i+1}. {paper['Title']} ({paper['Year']}; "
+            f"semantic_scholar_paper_id: {paper['semantic_scholar_paper_id']}; "
+            f"arXiv ID: {paper['arxiv_id']})"
             for i, paper in enumerate(top_papers)
         ]
     )
@@ -165,10 +189,10 @@ def get_multi_paper_recommendations(
         "Papers are attached as an artifact."
     )
     content += " Here is a summary of the recommendations:\n"
-    content += f"Number of papers found: {len(filtered_papers)}\n"
+    content += f"Number of recommended papers found: {len(filtered_papers)}\n"
     content += f"Query Paper IDs: {', '.join(paper_ids)}\n"
     content += f"Year: {year}\n" if year else ""
-    content += "Top papers:\n" + top_papers_info
+    content += "Here are a few of these papers:\n" + top_papers_info
 
     return Command(
         update={

aiagents4pharma/talk2scholars/tools/s2/query_results.py

@@ -44,7 +44,7 @@ def query_results(question: str, state: Annotated[dict, InjectedState]) -> str:
         raise NoPapersFoundError(
             "No papers found. A search needs to be performed first."
         )
-    context_key = state.get("last_displayed_papers","pdf_data")
+    context_key = state.get("last_displayed_papers", "pdf_data")
     dic_papers = state.get(context_key)
     df_papers = pd.DataFrame.from_dict(dic_papers, orient="index")
     df_agent = create_pandas_dataframe_agent(

aiagents4pharma/talk2scholars/tools/s2/search.py

@@ -14,6 +14,7 @@ from langchain_core.tools.base import InjectedToolCallId
 from langgraph.types import Command
 from pydantic import BaseModel, Field
 
+# pylint: disable=R0914,R0912,R0915
 # Configure logging
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
@@ -27,7 +28,7 @@ class SearchInput(BaseModel):
         "Be specific and include relevant academic terms."
     )
     limit: int = Field(
-        default=5, description="Maximum number of results to return", ge=1, le=100
+        default=10, description="Maximum number of results to return", ge=1, le=100
     )
     year: Optional[str] = Field(
         default=None,
@@ -75,14 +76,26 @@ def search_tool(
         params["year"] = year
 
     # Wrap API call in try/except to catch connectivity issues
-    try:
-        response = requests.get(endpoint, params=params, timeout=10)
-        response.raise_for_status()  # Raises HTTPError for bad responses
-    except requests.exceptions.RequestException as e:
-        logger.error("Failed to connect to Semantic Scholar API: %s", e)
-        raise RuntimeError(
-            "Failed to connect to Semantic Scholar API. Please retry the same query."
-        ) from e
+    response = None
+    for attempt in range(10):
+        try:
+            response = requests.get(endpoint, params=params, timeout=10)
+            response.raise_for_status()  # Raises HTTPError for bad responses
+            break  # Exit loop if request is successful
+        except requests.exceptions.RequestException as e:
+            logger.error(
+                "Attempt %d: Failed to connect to Semantic Scholar API: %s",
+                attempt + 1,
+                e,
+            )
+            if attempt == 9:  # Last attempt
+                raise RuntimeError(
+                    "Failed to connect to Semantic Scholar API after 10 attempts."
+                    "Please retry the same query."
+                ) from e
+
+    if response is None:
+        raise RuntimeError("Failed to obtain a response from the Semantic Scholar API.")
 
     data = response.json()
 
@@ -108,11 +121,22 @@ def search_tool(
     # Create a dictionary to store the papers
     filtered_papers = {
         paper["paperId"]: {
-            "paper_id": paper["paperId"],
+            "semantic_scholar_paper_id": paper["paperId"],
             "Title": paper.get("title", "N/A"),
             "Abstract": paper.get("abstract", "N/A"),
             "Year": paper.get("year", "N/A"),
+            "Publication Date": paper.get("publicationDate", "N/A"),
+            "Venue": paper.get("venue", "N/A"),
+            # "Publication Venue": (paper.get("publicationVenue") or {}).get("name", "N/A"),
+            # "Venue Type": (paper.get("publicationVenue") or {}).get("name", "N/A"),
+            "Journal Name": (paper.get("journal") or {}).get("name", "N/A"),
+            # "Journal Volume": paper.get("journal", {}).get("volume", "N/A"),
+            # "Journal Pages": paper.get("journal", {}).get("pages", "N/A"),
             "Citation Count": paper.get("citationCount", "N/A"),
+            "Authors": [
+                f"{author.get('name', 'N/A')} (ID: {author.get('authorId', 'N/A')})"
+                for author in paper.get("authors", [])
+            ],
             "URL": paper.get("url", "N/A"),
             "arxiv_id": paper.get("externalIds", {}).get("ArXiv", "N/A"),
         }
@@ -126,11 +150,15 @@ def search_tool(
     top_papers = list(filtered_papers.values())[:3]
     top_papers_info = "\n".join(
         [
-            f"{i+1}. {paper['Title']} ({paper['Year']})"
+            f"{i+1}. {paper['Title']} ({paper['Year']}; "
+            f"semantic_scholar_paper_id: {paper['semantic_scholar_paper_id']}; "
+            f"arXiv ID: {paper['arxiv_id']})"
             for i, paper in enumerate(top_papers)
         ]
     )
 
+    logger.info("-----------Filtered %d papers", len(filtered_papers))
+
     content = (
         "Search was successful. Papers are attached as an artifact. "
         "Here is a summary of the search results:\n"
@@ -138,7 +166,7 @@ def search_tool(
     content += f"Number of papers found: {len(filtered_papers)}\n"
     content += f"Query: {query}\n"
     content += f"Year: {year}\n" if year else ""
-    content += "Top papers:\n" + top_papers_info
+    content += "Top 3 papers:\n" + top_papers_info
 
     return Command(
         update={

aiagents4pharma/talk2scholars/tools/s2/single_paper_rec.py

@@ -14,6 +14,7 @@ from langchain_core.tools.base import InjectedToolCallId
 from langgraph.types import Command
 from pydantic import BaseModel, Field
 
+# pylint: disable=R0914,R0912,R0915
 # Configure logging
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
@@ -44,7 +45,7 @@ class SinglePaperRecInput(BaseModel):
 def get_single_paper_recommendations(
     paper_id: str,
     tool_call_id: Annotated[str, InjectedToolCallId],
-    limit: int = 5,
+    limit: int = 10,
     year: Optional[str] = None,
 ) -> Command[Any]:
     """
@@ -85,16 +86,28 @@ def get_single_paper_recommendations(
         params["year"] = year
 
     # Wrap API call in try/except to catch connectivity issues and check response format
-    try:
-        response = requests.get(endpoint, params=params, timeout=cfg.request_timeout)
-        response.raise_for_status()  # Raises HTTPError for bad responses
-    except requests.exceptions.RequestException as e:
-        logger.error(
-            "Failed to connect to Semantic Scholar API for recommendations: %s", e
-        )
-        raise RuntimeError(
-            "Failed to connect to Semantic Scholar API. Please retry the same query."
-        ) from e
+    response = None
+    for attempt in range(10):
+        try:
+            response = requests.get(
+                endpoint, params=params, timeout=cfg.request_timeout
+            )
+            response.raise_for_status()  # Raises HTTPError for bad responses
+            break  # Exit loop if request is successful
+        except requests.exceptions.RequestException as e:
+            logger.error(
+                "Attempt %d: Failed to connect to Semantic Scholar API for recommendations: %s",
+                attempt + 1,
+                e,
+            )
+            if attempt == 9:  # Last attempt
+                raise RuntimeError(
+                    "Failed to connect to Semantic Scholar API after 10 attempts."
+                    "Please retry the same query."
+                ) from e
+
+    if response is None:
+        raise RuntimeError("Failed to obtain a response from the Semantic Scholar API.")
 
     logger.info(
         "API Response Status for recommendations of paper %s: %s",
@@ -125,11 +138,22 @@ def get_single_paper_recommendations(
     # Extract paper ID and title from recommendations
     filtered_papers = {
         paper["paperId"]: {
-            "paper_id": paper["paperId"],
+            "semantic_scholar_paper_id": paper["paperId"],
             "Title": paper.get("title", "N/A"),
             "Abstract": paper.get("abstract", "N/A"),
             "Year": paper.get("year", "N/A"),
+            "Publication Date": paper.get("publicationDate", "N/A"),
+            "Venue": paper.get("venue", "N/A"),
+            # "Publication Venue": (paper.get("publicationVenue") or {}).get("name", "N/A"),
+            # "Venue Type": (paper.get("publicationVenue") or {}).get("name", "N/A"),
+            "Journal Name": (paper.get("journal") or {}).get("name", "N/A"),
+            # "Journal Volume": paper.get("journal", {}).get("volume", "N/A"),
+            # "Journal Pages": paper.get("journal", {}).get("pages", "N/A"),
             "Citation Count": paper.get("citationCount", "N/A"),
+            "Authors": [
+                f"{author.get('name', 'N/A')} (ID: {author.get('authorId', 'N/A')})"
+                for author in paper.get("authors", [])
+            ],
             "URL": paper.get("url", "N/A"),
             "arxiv_id": paper.get("externalIds", {}).get("ArXiv", "N/A"),
         }
@@ -141,7 +165,10 @@ def get_single_paper_recommendations(
     top_papers = list(filtered_papers.values())[:3]
     top_papers_info = "\n".join(
         [
-            f"{i+1}. {paper['Title']} ({paper['Year']})"
+            # f"{i+1}. {paper['Title']} ({paper['Year']})"
+            f"{i+1}. {paper['Title']} ({paper['Year']}; "
+            f"semantic_scholar_paper_id: {paper['semantic_scholar_paper_id']}; "
+            f"arXiv ID: {paper['arxiv_id']})"
             for i, paper in enumerate(top_papers)
         ]
     )
@@ -153,10 +180,9 @@ def get_single_paper_recommendations(
         "Papers are attached as an artifact. "
         "Here is a summary of the recommendations:\n"
     )
-    content += f"Number of papers found: {len(filtered_papers)}\n"
+    content += f"Number of recommended papers found: {len(filtered_papers)}\n"
     content += f"Query Paper ID: {paper_id}\n"
-    content += f"Year: {year}\n" if year else ""
-    content += "Top papers:\n" + top_papers_info
+    content += "Here are a few of these papers:\n" + top_papers_info
 
     return Command(
         update={

aiagents4pharma/talk2scholars/tools/zotero/__init__.py

@@ -5,3 +5,4 @@ Import statements
 from . import zotero_read
 from . import zotero_write
 from . import utils
+from . import zotero_review