aiagents4pharma 1.39.0__py3-none-any.whl → 1.39.2__py3-none-any.whl

aiagents4pharma/talk2scholars/tools/s2/multi_paper_rec.py

@@ -1,7 +1,11 @@
 #!/usr/bin/env python3
 
 """
-This tool is used to return recommendations based on multiple papers
+Recommend research papers related to a set of input papers using Semantic Scholar.
+
+Given a list of Semantic Scholar paper IDs, this tool aggregates related works
+(citations and references) from each input paper and returns a consolidated list
+of recommended papers.
 """
 
 import logging
@@ -20,47 +24,66 @@ logger = logging.getLogger(__name__)
 
 
 class MultiPaperRecInput(BaseModel):
-    """Input schema for multiple paper recommendations tool."""
+    """Defines the input schema for the multi-paper recommendation tool.
+
+    Attributes:
+        paper_ids: List of 40-character Semantic Scholar Paper IDs (provide at least two).
+        limit: Maximum total number of recommendations to return (1-500).
+        year: Optional publication year filter; supports formats:
+            'YYYY', 'YYYY-', '-YYYY', 'YYYY:YYYY'.
+        tool_call_id: Internal tool call identifier injected by the system.
+    """
 
     paper_ids: List[str] = Field(
-        description="List of Semantic Scholar Paper IDs to get recommendations for"
+        description="List of 40-character Semantic Scholar Paper IDs"
+        "(at least two) to base recommendations on"
     )
     limit: int = Field(
         default=10,
-        description="Maximum total number of recommendations to return",
+        description="Maximum total number of recommendations to return (1-500)",
         ge=1,
         le=500,
     )
     year: Optional[str] = Field(
         default=None,
-        description="Year range in format: YYYY for specific year, "
-        "YYYY- for papers after year, -YYYY for papers before year, or YYYY:YYYY for range",
+        description="Publication year filter; supports formats:"
+        "'YYYY', 'YYYY-', '-YYYY', 'YYYY:YYYY'",
     )
     tool_call_id: Annotated[str, InjectedToolCallId]
 
     model_config = {"arbitrary_types_allowed": True}
 
 
-@tool(args_schema=MultiPaperRecInput, parse_docstring=True)
+@tool(
+    args_schema=MultiPaperRecInput,
+    parse_docstring=True,
+)
 def get_multi_paper_recommendations(
     paper_ids: List[str],
     tool_call_id: Annotated[str, InjectedToolCallId],
-    limit: int = 2,
+    limit: int = 10,
     year: Optional[str] = None,
 ) -> Command[Any]:
     """
-    Get recommendations for a group of multiple papers using the Semantic Scholar IDs.
-    No other paper IDs are supported.
+    Return recommended papers based on multiple Semantic Scholar paper IDs.
+
+    This tool accepts a list of Semantic Scholar paper IDs and returns a set of
+    recommended papers by aggregating related works (citations and references)
+    from each input paper.
 
     Args:
-        paper_ids (List[str]): The list of paper IDs to base recommendations on.
-        tool_call_id (Annotated[str, InjectedToolCallId]): The tool call ID.
-        limit (int, optional): The maximum number of recommendations to return. Defaults to 2.
-        year (str, optional): Year range for papers.
-        Supports formats like "2024-", "-2024", "2024:2025". Defaults to None.
+        paper_ids (List[str]): List of 40-character Semantic Scholar paper IDs.
+        Provide at least two IDs.
+        tool_call_id (str): Internal tool call identifier injected by the system.
+        limit (int, optional): Maximum total number of recommendations to return. Defaults to 10.
+        year (str, optional): Publication year filter; supports formats: 'YYYY',
+        'YYYY-', '-YYYY', 'YYYY:YYYY'. Defaults to None.
 
     Returns:
-        Dict[str, Any]: The recommendations and related information.
+        Command: A Command object containing:
+            - multi_papers: List of recommended papers.
+            - last_displayed_papers: Same list for display purposes.
+            - messages: List containing a ToolMessage with recommendations details.
     """
     # Create recommendation data object to organize variables
     rec_data = MultiPaperRecData(paper_ids, limit, year, tool_call_id)

aiagents4pharma/talk2scholars/tools/s2/query_dataframe.py

@@ -10,11 +10,16 @@ or summarization. For PDF-level question answering, use the 'question_and_answer
 """
 
 import logging
-from typing import Annotated
+from typing import Annotated, Optional, Any
+
 import pandas as pd
-from langchain_experimental.agents import create_pandas_dataframe_agent
+from langchain_core.messages import ToolMessage
 from langchain_core.tools import tool
+from langchain_core.tools.base import InjectedToolCallId
+from langchain_experimental.agents import create_pandas_dataframe_agent
 from langgraph.prebuilt import InjectedState
+from langgraph.types import Command
+from pydantic import BaseModel, Field
 
 # Configure logging
 logging.basicConfig(level=logging.INFO)
@@ -25,8 +30,71 @@ class NoPapersFoundError(Exception):
     """Exception raised when no papers are found in the state."""
 
 
-@tool("query_dataframe", parse_docstring=True)
-def query_dataframe(question: str, state: Annotated[dict, InjectedState]) -> str:
+class QueryDataFrameInput(BaseModel):
+    """
+    Pydantic schema for querying the metadata of displayed papers.
+
+    Fields:
+      question: A free-text prompt or Python expression to query the papers DataFrame.
+      tool_call_id: LangGraph-injected identifier for tracking the tool invocation.
+      state: Agent state dictionary. Must include:
+        - 'last_displayed_papers': dictionary of paper metadata (rows = papers).
+        - 'llm_model': model used to instantiate the DataFrame agent.
+
+    Notes:
+      - This tool is only for metadata queries. It does not perform full-text PDF analysis.
+      - You can access standard metadata columns such as 'Title', 'Authors',
+        'Venue', 'Year', and the unified 'paper_ids' (list of <source>:<ID>).
+      - To extract raw paper IDs for downloading, set extract_ids=True and specify:
+          - id_column: 'paper_ids' (default)
+          - row_number: 1-based index of the paper to return (optional—for a single ID)
+        Example: {{"question":"","extract_ids":True,"row_number":4}}
+    """
+
+    question: str = Field(
+        description=(
+            "The metadata query to run over the papers DataFrame. Can be natural language "
+            "(e.g., 'List all titles by author X') or Python code "
+            "(e.g., df['arxiv_id'].dropna().tolist())."
+        )
+    )
+    extract_ids: bool = Field(
+        default=False,
+        description=(
+            "If true, instruct the DataFrame agent to extract values from the"
+            "specified ID column via a Python expression."
+        ),
+    )
+    id_column: str = Field(
+        default="paper_ids",
+        description=(
+            "Name of the metadata column containing a list of paper IDs to"
+            "extract when extract_ids=True."
+        ),
+    )
+    row_number: Optional[int] = Field(
+        default=None,
+        description=(
+            "1-based index of the ID to extract from the list; if provided, returns only"
+            "that single ID."
+        ),
+    )
+    tool_call_id: Annotated[str, InjectedToolCallId]
+    state: Annotated[dict, InjectedState]
+
+
+@tool(
+    "query_dataframe",
+    args_schema=QueryDataFrameInput,
+    parse_docstring=True,
+    return_direct=True,
+)
+def query_dataframe(
+    question: str,
+    state: Annotated[dict, InjectedState],
+    tool_call_id: str,
+    **kwargs: Any,
+) -> Command:
     """
     Perform a tabular query on the most recently displayed papers.
 
@@ -38,29 +106,63 @@ def query_dataframe(question: str, state: Annotated[dict, InjectedState]) -> str
 
     Args:
         question (str): The metadata query to ask over the papers table.
-        state (dict): The agent's state containing 'last_displayed_papers'
-            key referencing the metadata table in state.
+        extract_ids (bool): If true, modify the query to instruct the DataFrame agent
+        to extract values from the specified ID column via Python code.
+        id_column (str): Name of the metadata column to extract values from when extract_ids=True.
+        row_number (int, optional): 1-based index of the ID to extract from the list; if provided,
+        returns only that single ID.
+        state (dict): The agent's state containing 'last_displayed_papers' key
+        referencing the metadata table in state.
+        tool_call_id (str): LangGraph-injected identifier for this tool call.
 
     Returns:
-        str: The LLM's response to the metadata query.
+        Command: A structured response containing a ToolMessage with the query result.
 
     Raises:
         NoPapersFoundError: If no papers have been displayed yet.
     """
     logger.info("Querying last displayed papers with question: %s", question)
     llm_model = state.get("llm_model")
+    if llm_model is None:
+        raise ValueError("Missing 'llm_model' in state.")
+
     context_val = state.get("last_displayed_papers")
     if not context_val:
         logger.info("No papers displayed so far, raising NoPapersFoundError")
         raise NoPapersFoundError(
             "No papers found. A search needs to be performed first."
         )
-    # Support both key reference (str) and direct mapping
+
+    # Resolve the paper dictionary
     if isinstance(context_val, dict):
         dic_papers = context_val
     else:
         dic_papers = state.get(context_val)
+
+    if not isinstance(dic_papers, dict):
+        raise ValueError(
+            "Could not resolve a valid metadata dictionary from 'last_displayed_papers'"
+        )
+
     df_papers = pd.DataFrame.from_dict(dic_papers, orient="index")
+    # Prepare the query: if extracting IDs, let the DataFrame agent handle it via Python code
+    extract_ids_flag = kwargs.get("extract_ids", False)
+    id_column = kwargs.get("id_column", "paper_ids")
+    row_number = kwargs.get("row_number")
+    question_to_agent = question
+    if extract_ids_flag:
+        if not id_column:
+            raise ValueError("Must specify 'id_column' when extract_ids=True.")
+        if row_number is not None:
+            question_to_agent = (
+                f"df['{id_column}'].dropna().str[0].tolist()[{row_number-1}]"
+            )
+        else:
+            question_to_agent = f"df['{id_column}'].dropna().str[0].tolist()"
+        logger.info(
+            "extract_ids enabled: asking agent to run expression: %s", question_to_agent
+        )
+
     df_agent = create_pandas_dataframe_agent(
         llm_model,
         allow_dangerous_code=True,
@@ -71,5 +173,17 @@ def query_dataframe(question: str, state: Annotated[dict, InjectedState]) -> str
         number_of_head_rows=df_papers.shape[0],
         verbose=True,
     )
-    llm_result = df_agent.invoke(question, stream_mode=None)
-    return llm_result["output"]
+
+    llm_result = df_agent.invoke({"input": question_to_agent}, stream_mode=None)
+    response_text = llm_result["output"]
+
+    return Command(
+        update={
+            "messages": [
+                ToolMessage(
+                    content=response_text,
+                    tool_call_id=tool_call_id,
+                )
+            ],
+        }
+    )

aiagents4pharma/talk2scholars/tools/s2/retrieve_semantic_scholar_paper_id.py

@@ -1,7 +1,12 @@
 #!/usr/bin/env python3
 
 """
-This tool is used to search for academic papers on Semantic Scholar.
+Tool for retrieving a Semantic Scholar paper ID given a paper title.
+
+This tool queries the Semantic Scholar API for the best match of the provided paper title
+and returns the unique Semantic Scholar paperId. Use when you have a known title and need its
+Semantic Scholar identifier for further metadata retrieval or pipeline integration. Do not
+use this tool for broad literature search; use the `search` tool instead.
 """
 
 import logging
@@ -12,7 +17,7 @@ from langchain_core.messages import ToolMessage
 from langchain_core.tools import tool
 from langchain_core.tools.base import InjectedToolCallId
 from langgraph.types import Command
-from pydantic import Field
+from pydantic import BaseModel, Field
 
 
 # Configure logging
@@ -20,26 +25,51 @@ logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
 
-@tool("retrieve_semantic_scholar_paper_id", parse_docstring=True)
-def retrieve_semantic_scholar_paper_id(
-    tool_call_id: Annotated[str, InjectedToolCallId],
+class RetrieveSemanticScholarPaperIdInput(BaseModel):
+    """
+    Pydantic schema for retrieving a Semantic Scholar paper ID.
+
+    Fields:
+      paper_title: The title (full or partial) of the paper to look up on Semantic Scholar.
+      tool_call_id: LangGraph-injected identifier for tracking the tool invocation.
+    """
+
     paper_title: str = Field(
-        description="The title of the paper to search for on Semantic Scholar."
-    ),
+        ..., description="The paper title to search for on Semantic Scholar."
+    )
+    tool_call_id: Annotated[str, InjectedToolCallId]
+
+
+@tool(
+    "retrieve_semantic_scholar_paper_id",
+    args_schema=RetrieveSemanticScholarPaperIdInput,
+    parse_docstring=True,
+)
+def retrieve_semantic_scholar_paper_id(
+    paper_title: str,
+    tool_call_id: str,
 ) -> Command[Any]:
     """
-    This tool can be used to search for a paper on Semantic Scholar
-    and retrieve the paper Semantic Scholar ID.
+    Search for a paper by title on Semantic Scholar and return its unique paper ID.
 
-    This is useful for when an article is retrieved from users Zotero library
-    and the Semantic Scholar ID is needed to retrieve more information about the paper.
+    This tool issues a GET request to the Semantic Scholar API to find the best match
+    for the given paper title, then returns the paper's Semantic Scholar ID.
+
+    Use when you have a known title (full or partial) and need the Semantic Scholar ID
+    to fetch additional metadata or perform downstream lookups. Do not use this tool
+    for broad literature searches; for general search use the `search` tool.
 
     Args:
-        tool_call_id (Annotated[str, InjectedToolCallId]): The tool call ID.
-        paper_title (str): The title of the paper to search for on Semantic Scholar.
+        paper_title (str): The title of the paper to look up.
+        tool_call_id (str): LangGraph-injected identifier for this tool call.
 
     Returns:
-        ToolMessage: A message containing the paper ID.
+        Command: A structured response containing a ToolMessage whose content is
+          the Semantic Scholar paper ID string (e.g., 'abc123xyz').
+
+    Raises:
+        ValueError: If no matching paper is found for the given title.
+        requests.RequestException: If the API request fails.
     """
     # Load hydra configuration
     with hydra.initialize(version_base=None, config_path="../../configs"):
@@ -64,14 +94,16 @@ def retrieve_semantic_scholar_paper_id(
     if not papers:
         logger.error("No papers found for query: %s", paper_title)
         raise ValueError(f"No papers found for query: {paper_title}. Try again.")
-    # Get the paper ID
+    # Extract the paper ID from the top result
     paper_id = papers[0]["paperId"]
-
+    logger.info("Found paper ID: %s", paper_id)
+    # Prepare the response content (just the ID)
+    response_text = paper_id
     return Command(
         update={
             "messages": [
                 ToolMessage(
-                    content=f"Paper ID for '{paper_title}' is: {paper_id}",
+                    content=response_text,
                     tool_call_id=tool_call_id,
                 )
             ],

aiagents4pharma/talk2scholars/tools/s2/search.py

@@ -1,7 +1,10 @@
 #!/usr/bin/env python3
 
 """
-This tool is used to search for academic papers on Semantic Scholar.
+Search for academic papers on Semantic Scholar by title or keywords.
+
+Given a text query, this tool retrieves relevant papers from Semantic Scholar,
+optionally filtered by publication year.
 """
 
 import logging
@@ -19,42 +22,62 @@ logger = logging.getLogger(__name__)
 
 
 class SearchInput(BaseModel):
-    """Input schema for the search papers tool."""
+    """Defines the input schema for the paper search tool.
+
+    Attributes:
+        query: Full or partial paper title or keywords to search for.
+        limit: Maximum number of search results to return (1-100).
+        year: Optional publication year filter; supports 'YYYY',
+        'YYYY-', '-YYYY', 'YYYY:YYYY'.
+        tool_call_id: Internal tool call identifier injected by the system.
+    """
 
     query: str = Field(
-        description="Search query string to find academic papers."
-        "Be specific and include relevant academic terms."
+        description="Full or partial paper title or keywords to search for"
     )
     limit: int = Field(
-        default=10, description="Maximum number of results to return", ge=1, le=100
+        default=10,
+        description="Maximum number of search results to return (1-100)",
+        ge=1,
+        le=100,
     )
     year: Optional[str] = Field(
         default=None,
-        description="Year range in format: YYYY for specific year, "
-        "YYYY- for papers after year, -YYYY for papers before year, or YYYY:YYYY for range",
+        description="Publication year filter; supports formats:"
+        "'YYYY', 'YYYY-', '-YYYY', 'YYYY:YYYY'",
     )
     tool_call_id: Annotated[str, InjectedToolCallId]
 
 
-@tool("search_tool", args_schema=SearchInput, parse_docstring=True)
+@tool(
+    "search_tool",
+    args_schema=SearchInput,
+    parse_docstring=True,
+)
 def search_tool(
     query: str,
     tool_call_id: Annotated[str, InjectedToolCallId],
-    limit: int = 5,
+    limit: int = 10,
     year: Optional[str] = None,
 ) -> Command[Any]:
     """
-    Search for academic papers on Semantic Scholar.
+    Return academic papers from Semantic Scholar matching a title or keyword query.
+
+    This tool searches Semantic Scholar for papers whose titles or keywords
+    match the given text, optionally filtered by publication year.
 
     Args:
-        query (str): The search query string to find academic papers.
-        tool_call_id (Annotated[str, InjectedToolCallId]): The tool call ID.
-        limit (int, optional): The maximum number of results to return. Defaults to 5.
-        year (str, optional): Year range for papers.
-        Supports formats like "2024-", "-2024", "2024:2025". Defaults to None.
+        query (str): Full or partial paper title or keywords to search for.
+        tool_call_id (str): Internal tool call identifier injected by the system.
+        limit (int, optional): Maximum number of search results to return. Defaults to 5.
+        year (str, optional): Publication year filter; supports 'YYYY',
+        'YYYY-', '-YYYY', 'YYYY:YYYY'. Defaults to None.
 
     Returns:
-        The number of papers found on Semantic Scholar.
+        Command: A Command object containing:
+            - papers: List of matching papers.
+            - last_displayed_papers: Same list for display purposes.
+            - messages: List containing a ToolMessage with search results details.
     """
     # Create search data object to organize variables
     search_data = SearchData(query, limit, year, tool_call_id)

aiagents4pharma/talk2scholars/tools/s2/single_paper_rec.py

@@ -1,7 +1,10 @@
 #!/usr/bin/env python3
 
 """
-This tool is used to return recommendations for a single paper.
+Recommend research papers related to a single input paper using Semantic Scholar.
+
+Given a Semantic Scholar paper ID, this tool retrieves related works
+(citations and references) and returns a curated list of recommended papers.
 """
 
 import logging
@@ -19,27 +22,37 @@ logger = logging.getLogger(__name__)
 
 
 class SinglePaperRecInput(BaseModel):
-    """Input schema for single paper recommendation tool."""
+    """Defines the input schema for the single-paper recommendation tool.
+
+    Attributes:
+        paper_id: 40-character Semantic Scholar Paper ID to base recommendations on.
+        limit: Maximum number of recommendations to return (1-500).
+        year: Optional publication year filter; supports 'YYYY', 'YYYY-', '-YYYY', 'YYYY:YYYY'.
+        tool_call_id: Internal tool call identifier injected by the system.
+    """
 
     paper_id: str = Field(
-        description="Semantic Scholar Paper ID to get recommendations for (40-character string)"
+        description="40-character Semantic Scholar Paper ID to base recommendations on"
     )
     limit: int = Field(
-        default=5,
-        description="Maximum number of recommendations to return",
+        default=10,
+        description="Maximum number of recommendations to return (1-500)",
         ge=1,
         le=500,
     )
     year: Optional[str] = Field(
         default=None,
-        description="Year range in format: YYYY for specific year, "
-        "YYYY- for papers after year, -YYYY for papers before year, or YYYY:YYYY for range",
+        description="Publication year filter; supports formats::"
+        "'YYYY', 'YYYY-', '-YYYY', 'YYYY:YYYY'",
     )
     tool_call_id: Annotated[str, InjectedToolCallId]
     model_config = {"arbitrary_types_allowed": True}
 
 
-@tool(args_schema=SinglePaperRecInput, parse_docstring=True)
+@tool(
+    args_schema=SinglePaperRecInput,
+    parse_docstring=True,
+)
 def get_single_paper_recommendations(
     paper_id: str,
     tool_call_id: Annotated[str, InjectedToolCallId],
@@ -47,18 +60,23 @@ def get_single_paper_recommendations(
     year: Optional[str] = None,
 ) -> Command[Any]:
     """
-    Get recommendations for a single paper using its Semantic Scholar ID.
-    No other ID types are supported.
+    Return recommended papers for a single Semantic Scholar paper ID.
+
+    This tool accepts a single Semantic Scholar paper ID and returns related works
+    by aggregating citations and references.
 
     Args:
-        paper_id (str): The Semantic Scholar Paper ID to get recommendations for.
-        tool_call_id (Annotated[str, InjectedToolCallId]): The tool call ID.
-        limit (int, optional): The maximum number of recommendations to return. Defaults to 5.
-        year (str, optional): Year range for papers.
-        Supports formats like "2024-", "-2024", "2024:2025". Defaults to None.
+        paper_id (str): 40-character Semantic Scholar paper ID.
+        tool_call_id (str): Internal tool call identifier injected by the system.
+        limit (int, optional): Maximum number of recommendations to return. Defaults to 5.
+        year (str, optional): Publication year filter; supports 'YYYY', 'YYYY-',
+        '-YYYY', 'YYYY:YYYY'. Defaults to None.
 
     Returns:
-        Dict[str, Any]: The recommendations and related information.
+        Command: A Command object containing:
+            - papers: List of recommended papers.
+            - last_displayed_papers: Same list for display purposes.
+            - messages: List containing a ToolMessage with recommendation details.
     """
     # Create recommendation data object to organize variables
     rec_data = SinglePaperRecData(paper_id, limit, year, tool_call_id)

aiagents4pharma/talk2scholars/tools/s2/utils/multi_helper.py

@@ -127,8 +127,26 @@ class MultiPaperRecData:
 
     def _filter_papers(self) -> None:
         """Filter and format papers."""
-        self.filtered_papers = {
-            paper["paperId"]: {
+        # Build filtered recommendations with unified paper_ids
+        filtered: Dict[str, Any] = {}
+        for paper in self.recommendations:
+            if not paper.get("title") or not paper.get("authors"):
+                continue
+            ext = paper.get("externalIds", {}) or {}
+            ids: List[str] = []
+            arxiv = ext.get("ArXiv")
+            if arxiv:
+                ids.append(f"arxiv:{arxiv}")
+            pubmed = ext.get("PubMed")
+            if pubmed:
+                ids.append(f"pubmed:{pubmed}")
+            pmc = ext.get("PubMedCentral")
+            if pmc:
+                ids.append(f"pmc:{pmc}")
+            doi_id = ext.get("DOI")
+            if doi_id:
+                ids.append(f"doi:{doi_id}")
+            metadata = {
                 "semantic_scholar_paper_id": paper["paperId"],
                 "Title": paper.get("title", "N/A"),
                 "Abstract": paper.get("abstract", "N/A"),
@@ -142,27 +160,42 @@ class MultiPaperRecData:
                     for author in paper.get("authors", [])
                 ],
                 "URL": paper.get("url", "N/A"),
-                "arxiv_id": paper.get("externalIds", {}).get("ArXiv", "N/A"),
-                "doi": paper.get("externalIds", {}).get("DOI", "N/A"),
+                "arxiv_id": arxiv or "N/A",
+                "pm_id": pubmed or "N/A",
+                "pmc_id": pmc or "N/A",
+                "doi": doi_id or "N/A",
+                "paper_ids": ids,
+                "source": "semantic_scholar",
             }
-            for paper in self.recommendations
-            if paper.get("title") and paper.get("authors")
-        }
+            filtered[paper["paperId"]] = metadata
+        self.filtered_papers = filtered
 
         logger.info("Filtered %d papers", len(self.filtered_papers))
 
+    def _get_snippet(self, abstract: str) -> str:
+        """Extract the first one or two sentences from an abstract."""
+        if not abstract or abstract == "N/A":
+            return ""
+        sentences = abstract.split(". ")
+        snippet_sentences = sentences[:2]
+        snippet = ". ".join(snippet_sentences)
+        if not snippet.endswith("."):
+            snippet += "."
+        return snippet
+
     def _create_content(self) -> None:
         """Create the content message for the response."""
         top_papers = list(self.filtered_papers.values())[:3]
-        top_papers_info = "\n".join(
-            [
-                f"{i+1}. {paper['Title']} ({paper['Year']}; "
-                f"semantic_scholar_paper_id: {paper['semantic_scholar_paper_id']}; "
-                f"arXiv ID: {paper['arxiv_id']})"
-                f"doi: {paper['doi']})"
-                for i, paper in enumerate(top_papers)
-            ]
-        )
+        entries: list[str] = []
+        for i, paper in enumerate(top_papers):
+            title = paper.get("Title", "N/A")
+            year = paper.get("Year", "N/A")
+            snippet = self._get_snippet(paper.get("Abstract", ""))
+            entry = f"{i+1}. {title} ({year})"
+            if snippet:
+                entry += f"\n   Abstract snippet: {snippet}"
+            entries.append(entry)
+        top_papers_info = "\n".join(entries)
 
         self.content = (
             "Recommendations based on multiple papers were successful. "