aiagents4pharma 1.43.0__py3-none-any.whl → 1.45.0__py3-none-any.whl

aiagents4pharma/talk2scholars/tools/pdf/utils/generate_answer.py

@@ -4,7 +4,7 @@ Generate an answer for a question using retrieved chunks of documents.
 
 import logging
 import os
-from typing import Any, Dict, List
+from typing import Any
 
 import hydra
 from langchain_core.documents import Document
@@ -32,7 +32,7 @@ def load_hydra_config() -> Any:
 
 
 def _build_context_and_sources(
-    retrieved_chunks: List[Document],
+    retrieved_chunks: list[Document],
 ) -> tuple[str, set[str]]:
     """
     Build the combined context string and set of paper_ids from retrieved chunks.
@@ -61,10 +61,10 @@ def _build_context_and_sources(
 
 def generate_answer(
     question: str,
-    retrieved_chunks: List[Document],
+    retrieved_chunks: list[Document],
     llm_model: BaseChatModel,
     config: Any,
-) -> Dict[str, Any]:
+) -> dict[str, Any]:
     """
     Generate an answer for a question using retrieved chunks.
 

aiagents4pharma/talk2scholars/tools/pdf/utils/get_vectorstore.py

@@ -37,14 +37,10 @@ def get_vectorstore(
     with _cache_lock:
         if force_new and collection_name in _vectorstore_cache:
             del _vectorstore_cache[collection_name]
-            logger.info(
-                "Forced new Vectorstore instance for collection: %s", collection_name
-            )
+            logger.info("Forced new Vectorstore instance for collection: %s", collection_name)
 
         if collection_name not in _vectorstore_cache:
-            logger.info(
-                "Creating new Vectorstore instance for collection: %s", collection_name
-            )
+            logger.info("Creating new Vectorstore instance for collection: %s", collection_name)
             _vectorstore_cache[collection_name] = Vectorstore(
                 embedding_model=embedding_model, config=config
             )

aiagents4pharma/talk2scholars/tools/pdf/utils/gpu_detection.py

@@ -5,7 +5,7 @@ Handle COSINE -> IP conversion for GPU indexes
 
 import logging
 import subprocess
-from typing import Dict, Any, Tuple
+from typing import Any
 
 logger = logging.getLogger(__name__)
 
@@ -56,7 +56,7 @@ def detect_nvidia_gpu(config=None) -> bool:
 
 def get_optimal_index_config(
     has_gpu: bool, embedding_dim: int = 768, use_cosine: bool = True
-) -> Tuple[Dict[str, Any], Dict[str, Any]]:
+) -> tuple[dict[str, Any], dict[str, Any]]:
     """
     Get optimal index and search parameters based on GPU availability.
 
@@ -80,9 +80,7 @@ def get_optimal_index_config(
                 "GPU indexes don't support COSINE distance. "
                 "Vectors will be normalized and IP distance will be used instead."
             )
-            metric_type = (
-                "IP"  # Inner Product for normalized vectors = cosine similarity
-            )
+            metric_type = "IP"  # Inner Product for normalized vectors = cosine similarity
         else:
             metric_type = "IP"  # Default to IP for GPU
 
@@ -120,9 +118,7 @@ def get_optimal_index_config(
             "index_type": "IVF_FLAT",
             "metric_type": metric_type,
             "params": {
-                "nlist": min(
-                    1024, max(64, embedding_dim // 8)
-                )  # Dynamic nlist based on dimension
+                "nlist": min(1024, max(64, embedding_dim // 8))  # Dynamic nlist based on dimension
             },
         }
 
@@ -136,7 +132,7 @@ def get_optimal_index_config(
 
 
 def log_index_configuration(
-    index_params: Dict[str, Any], search_params: Dict[str, Any], use_cosine: bool = True
+    index_params: dict[str, Any], search_params: dict[str, Any], use_cosine: bool = True
 ) -> None:
     """Log the selected index configuration for debugging."""
     index_type = index_params.get("index_type", "Unknown")

aiagents4pharma/talk2scholars/tools/pdf/utils/nvidia_nim_reranker.py

@@ -5,7 +5,7 @@ Rerank chunks instead of papers following traditional RAG pipeline
 
 import logging
 import os
-from typing import Any, List
+from typing import Any
 
 from langchain_core.documents import Document
 from langchain_nvidia_ai_endpoints import NVIDIARerank
@@ -18,8 +18,8 @@ logger.setLevel(getattr(logging, log_level))
 
 
 def rerank_chunks(
-    chunks: List[Document], query: str, config: Any, top_k: int = 25
-) -> List[Document]:
+    chunks: list[Document], query: str, config: Any, top_k: int = 25
+) -> list[Document]:
     """
     Rerank chunks by relevance to the query using NVIDIA's reranker.
 
@@ -68,7 +68,7 @@ def rerank_chunks(
     # Log chunk metadata for debugging
     logger.debug(
         "Reranking chunks from papers: %s",
-        list(set(chunk.metadata.get("paper_id", "unknown") for chunk in chunks))[:5],
+        list({chunk.metadata.get("paper_id", "unknown") for chunk in chunks})[:5],
     )
 
     # Rerank the chunks

aiagents4pharma/talk2scholars/tools/pdf/utils/paper_loader.py

@@ -3,7 +3,7 @@ Paper loading utilities for managing PDF documents in vector store.
 """
 
 import logging
-from typing import Any, Dict
+from typing import Any
 
 from .batch_processor import add_papers_batch
 
@@ -12,7 +12,7 @@ logger = logging.getLogger(__name__)
 
 def load_all_papers(
     vector_store: Any,  # The Vectorstore instance
-    articles: Dict[str, Any],
+    articles: dict[str, Any],
     call_id: str,
     config: Any,
     has_gpu: bool,

aiagents4pharma/talk2scholars/tools/pdf/utils/rag_pipeline.py

@@ -3,8 +3,7 @@ RAG pipeline for retrieving and reranking chunks from a vector store.
 """
 
 import logging
-from typing import Any, List
-
+from typing import Any
 
 # Import our GPU detection utility
 from .nvidia_nim_reranker import rerank_chunks
@@ -15,7 +14,7 @@ logger = logging.getLogger(__name__)
 
 def retrieve_and_rerank_chunks(
     vector_store: Any, query: str, config: Any, call_id: str, has_gpu: bool
-) -> List[Any]:
+) -> list[Any]:
     """
     Traditional RAG pipeline: retrieve chunks from all papers, then rerank.
     Optimized for GPU/CPU hardware.
@@ -38,12 +37,8 @@ def retrieve_and_rerank_chunks(
     # Adjust initial retrieval count based on hardware
     if has_gpu:
         # GPU can handle larger initial retrieval efficiently
-        initial_chunks_count = config.get(
-            "initial_retrieval_k", 150
-        )  # Increased for GPU
-        mmr_diversity = config.get(
-            "mmr_diversity", 0.75
-        )  # Slightly more diverse for larger sets
+        initial_chunks_count = config.get("initial_retrieval_k", 150)  # Increased for GPU
+        mmr_diversity = config.get("mmr_diversity", 0.75)  # Slightly more diverse for larger sets
     else:
         # CPU - use conservative settings
         initial_chunks_count = config.get("initial_retrieval_k", 100)  # Original
@@ -72,9 +67,7 @@ def retrieve_and_rerank_chunks(
         "%s: Retrieved %d chunks from %d unique papers using %s",
         call_id,
         len(retrieved_chunks),
-        len(
-            set(chunk.metadata.get("paper_id", "unknown") for chunk in retrieved_chunks)
-        ),
+        len({chunk.metadata.get("paper_id", "unknown") for chunk in retrieved_chunks}),
         hardware_mode,
     )
 
@@ -95,9 +88,7 @@ def retrieve_and_rerank_chunks(
     )
 
     # Log final results with hardware info
-    final_papers = len(
-        set(chunk.metadata.get("paper_id", "unknown") for chunk in reranked_chunks)
-    )
+    final_papers = len({chunk.metadata.get("paper_id", "unknown") for chunk in reranked_chunks})
 
     logger.info(
         "%s: Reranking complete using %s. Final %d chunks from %d unique papers",

aiagents4pharma/talk2scholars/tools/pdf/utils/retrieve_chunks.py

@@ -6,11 +6,9 @@ With automatic GPU/CPU search parameter optimization.
 
 import logging
 import os
-from typing import List, Optional
 
 from langchain_core.documents import Document
 
-
 # Set up logging with configurable level
 log_level = os.environ.get("LOG_LEVEL", "INFO")
 logging.basicConfig(level=getattr(logging, log_level))
@@ -21,10 +19,10 @@ logger.setLevel(getattr(logging, log_level))
 def retrieve_relevant_chunks(
     vector_store,
     query: str,
-    paper_ids: Optional[List[str]] = None,
+    paper_ids: list[str] | None = None,
     top_k: int = 100,  # Increased default to cast wider net before reranking
     mmr_diversity: float = 0.8,  # Slightly reduced for better diversity
-) -> List[Document]:
+) -> list[Document]:
     """
     Retrieve the most relevant chunks for a query using maximal marginal relevance.
     Automatically uses GPU-optimized search parameters if GPU is available.
@@ -104,9 +102,7 @@ def retrieve_relevant_chunks(
         filter=filter_dict,
     )
 
-    logger.info(
-        "Retrieved %d chunks using %s MMR from Milvus", len(results), search_mode
-    )
+    logger.info("Retrieved %d chunks using %s MMR from Milvus", len(results), search_mode)
 
     # Log some details about retrieved chunks for debugging
     if results and logger.isEnabledFor(logging.DEBUG):
@@ -132,10 +128,10 @@ def retrieve_relevant_chunks(
 def retrieve_relevant_chunks_with_scores(
     vector_store,
     query: str,
-    paper_ids: Optional[List[str]] = None,
+    paper_ids: list[str] | None = None,
     top_k: int = 100,
     score_threshold: float = 0.0,
-) -> List[tuple[Document, float]]:
+) -> list[tuple[Document, float]]:
     """
     Retrieve chunks with similarity scores, optimized for GPU/CPU.
 
@@ -186,9 +182,7 @@ def retrieve_relevant_chunks_with_scores(
         )
 
         # Filter by score threshold
-        filtered_results = [
-            (doc, score) for doc, score in results if score >= score_threshold
-        ]
+        filtered_results = [(doc, score) for doc, score in results if score >= score_threshold]
 
         logger.info(
             "%s search with scores retrieved %d/%d chunks above threshold %.3f",
@@ -200,6 +194,4 @@ def retrieve_relevant_chunks_with_scores(
 
         return filtered_results
 
-    raise NotImplementedError(
-        "Vector store does not support similarity_search_with_score"
-    )
+    raise NotImplementedError("Vector store does not support similarity_search_with_score")

aiagents4pharma/talk2scholars/tools/pdf/utils/singleton_manager.py

@@ -6,7 +6,7 @@ Handles connection reuse, event loops, and GPU detection caching.
 import asyncio
 import logging
 import threading
-from typing import Any, Dict
+from typing import Any
 
 from langchain_core.embeddings import Embeddings
 from langchain_milvus import Milvus
@@ -105,7 +105,7 @@ class VectorstoreSingleton:
         self,
         collection_name: str,
         embedding_model: Embeddings,
-        connection_args: Dict[str, Any],
+        connection_args: dict[str, Any],
     ) -> Milvus:
         """Get or create a vector store for a collection."""
         if collection_name not in self._vector_stores:

aiagents4pharma/talk2scholars/tools/pdf/utils/tool_helper.py

@@ -3,8 +3,7 @@ Helper class for question and answer tool in PDF processing.
 """
 
 import logging
-from typing import Any, Dict
-
+from typing import Any
 
 from .get_vectorstore import get_vectorstore
 
@@ -29,7 +28,7 @@ class QAToolHelper:
         self.call_id = call_id
         logger.debug("QAToolHelper started call %s", call_id)
 
-    def get_state_models_and_data(self, state: dict) -> tuple[Any, Any, Dict[str, Any]]:
+    def get_state_models_and_data(self, state: dict) -> tuple[Any, Any, dict[str, Any]]:
         """Retrieve embedding model, LLM, and article data from agent state."""
         text_emb = state.get("text_embedding_model")
         if not text_emb:
@@ -78,7 +77,7 @@ class QAToolHelper:
 
         return vs
 
-    def get_hardware_stats(self) -> Dict[str, Any]:
+    def get_hardware_stats(self) -> dict[str, Any]:
         """Get current hardware configuration stats for monitoring."""
         return {
             "gpu_available": self.has_gpu,

aiagents4pharma/talk2scholars/tools/pdf/utils/vector_normalization.py

@@ -5,7 +5,6 @@ and use IP (Inner Product) distance instead.
 """
 
 import logging
-from typing import List, Union
 
 import numpy as np
 from langchain_core.embeddings import Embeddings
@@ -13,7 +12,7 @@ from langchain_core.embeddings import Embeddings
 logger = logging.getLogger(__name__)
 
 
-def normalize_vector(vector: Union[List[float], np.ndarray]) -> List[float]:
+def normalize_vector(vector: list[float] | np.ndarray) -> list[float]:
     """
     Normalize a single vector to unit length.
 
@@ -34,7 +33,7 @@ def normalize_vector(vector: Union[List[float], np.ndarray]) -> List[float]:
     return normalized.tolist()
 
 
-def normalize_vectors_batch(vectors: List[List[float]]) -> List[List[float]]:
+def normalize_vectors_batch(vectors: list[list[float]]) -> list[list[float]]:
     """
     Normalize a batch of vectors to unit length.
 
@@ -56,9 +55,7 @@ def normalize_vectors_batch(vectors: List[List[float]]) -> List[List[float]]:
     # Handle zero vectors
     zero_mask = norms.flatten() == 0
     if np.any(zero_mask):
-        logger.warning(
-            "Found %d zero vectors during batch normalization", np.sum(zero_mask)
-        )
+        logger.warning("Found %d zero vectors during batch normalization", np.sum(zero_mask))
         norms[zero_mask] = 1.0  # Avoid division by zero
 
     # Normalize
@@ -85,11 +82,9 @@ class NormalizingEmbeddings(Embeddings):
         self.normalize_for_gpu = normalize_for_gpu
 
         if normalize_for_gpu:
-            logger.info(
-                "Embedding model wrapped with normalization for GPU compatibility"
-            )
+            logger.info("Embedding model wrapped with normalization for GPU compatibility")
 
-    def embed_documents(self, texts: List[str]) -> List[List[float]]:
+    def embed_documents(self, texts: list[str]) -> list[list[float]]:
         """Embed documents and optionally normalize."""
         embeddings = self.embedding_model.embed_documents(texts)
 
@@ -99,7 +94,7 @@ class NormalizingEmbeddings(Embeddings):
 
         return embeddings
 
-    def embed_query(self, text: str) -> List[float]:
+    def embed_query(self, text: str) -> list[float]:
         """Embed query and optionally normalize."""
         embedding = self.embedding_model.embed_query(text)
 
@@ -128,13 +123,9 @@ def should_normalize_vectors(has_gpu: bool, use_cosine: bool) -> bool:
     needs_normalization = has_gpu and use_cosine
 
     if needs_normalization:
-        logger.info(
-            "Vector normalization ENABLED: GPU detected with COSINE similarity request"
-        )
+        logger.info("Vector normalization ENABLED: GPU detected with COSINE similarity request")
     else:
-        logger.info(
-            "Vector normalization DISABLED: GPU=%s, COSINE=%s", has_gpu, use_cosine
-        )
+        logger.info("Vector normalization DISABLED: GPU=%s, COSINE=%s", has_gpu, use_cosine)
 
     return needs_normalization
 

aiagents4pharma/talk2scholars/tools/pdf/utils/vector_store.py

@@ -8,7 +8,7 @@ Supports both GPU and CPU configurations.
 import logging
 import os
 import time
-from typing import Any, Dict, List, Optional
+from typing import Any
 
 from langchain_core.documents import Document
 from langchain_core.embeddings import Embeddings
@@ -39,7 +39,7 @@ class Vectorstore:
     def __init__(
         self,
         embedding_model: Embeddings,
-        metadata_fields: Optional[List[str]] = None,
+        metadata_fields: list[str] | None = None,
         config: Any = None,
     ):
         """
@@ -96,12 +96,8 @@ class Vectorstore:
 
         # Initialize Milvus connection parameters with environment variable fallback
         self.connection_args = {
-            "host": (
-                config.milvus.host if config else os.getenv("MILVUS_HOST", "127.0.0.1")
-            ),
-            "port": (
-                config.milvus.port if config else int(os.getenv("MILVUS_PORT", "19530"))
-            ),
+            "host": (config.milvus.host if config else os.getenv("MILVUS_HOST", "127.0.0.1")),
+            "port": (config.milvus.port if config else int(os.getenv("MILVUS_PORT", "19530"))),
         }
         # Log the connection parameters being used
         logger.info(
@@ -109,9 +105,7 @@ class Vectorstore:
             self.connection_args["host"],
             self.connection_args["port"],
         )
-        self.collection_name = (
-            config.milvus.collection_name if config else "pdf_rag_documents"
-        )
+        self.collection_name = config.milvus.collection_name if config else "pdf_rag_documents"
         self.db_name = config.milvus.db_name if config else "pdf_rag_db"
 
         # Get singleton instance
@@ -139,8 +133,8 @@ class Vectorstore:
         self._ensure_collection_loaded()
 
         # Store for document metadata (keeping for compatibility)
-        self.documents: Dict[str, Document] = {}
-        self.paper_metadata: Dict[str, Dict[str, Any]] = {}
+        self.documents: dict[str, Document] = {}
+        self.paper_metadata: dict[str, dict[str, Any]] = {}
 
         # Log final configuration
         metric_info = (
@@ -182,9 +176,7 @@ class Vectorstore:
             langchain_collection = getattr(self.vector_store, "collection", None)
 
         if langchain_collection is None:
-            logger.warning(
-                "No LangChain collection found, proceeding with empty loaded_papers"
-            )
+            logger.warning("No LangChain collection found, proceeding with empty loaded_papers")
             return
 
         # Force flush and check entity count
@@ -204,14 +196,14 @@ class Vectorstore:
             )
 
             # Extract unique paper IDs
-            existing_paper_ids = set(result["paper_id"] for result in results)
+            existing_paper_ids = {result["paper_id"] for result in results}
             self.loaded_papers.update(existing_paper_ids)
 
             logger.info("Found %d unique papers in collection", len(existing_paper_ids))
         else:
             logger.info("Collection is empty - no existing papers")
 
-    def similarity_search(self, query: str, **kwargs: Any) -> List[Document]:
+    def similarity_search(self, query: str, **kwargs: Any) -> list[Document]:
         """
         Perform similarity search on the vector store.
         Query embedding will be automatically normalized if using GPU with COSINE.
@@ -222,7 +214,7 @@ class Vectorstore:
         """
         # Extract our parameters
         k: int = kwargs.pop("k", 4)
-        filter_: Optional[Dict[str, Any]] = kwargs.pop("filter", None)
+        filter_: dict[str, Any] | None = kwargs.pop("filter", None)
 
         # Build Milvus expr from filter_, if present
         expr = None
@@ -232,22 +224,16 @@ class Vectorstore:
                 if isinstance(value, str):
                     conditions.append(f'{key} == "{value}"')
                 elif isinstance(value, list):
-                    vals = ", ".join(
-                        f'"{v}"' if isinstance(v, str) else str(v) for v in value
-                    )
+                    vals = ", ".join(f'"{v}"' if isinstance(v, str) else str(v) for v in value)
                     conditions.append(f"{key} in [{vals}]")
                 else:
                     conditions.append(f"{key} == {value}")
             expr = " and ".join(conditions)
 
         # Delegate to the wrapped store
-        return self.vector_store.similarity_search(
-            query=query, k=k, expr=expr, **kwargs
-        )
+        return self.vector_store.similarity_search(query=query, k=k, expr=expr, **kwargs)
 
-    def max_marginal_relevance_search(
-        self, query: str, **kwargs: Any
-    ) -> List[Document]:
+    def max_marginal_relevance_search(self, query: str, **kwargs: Any) -> list[Document]:
         """
         Perform MMR search on the vector store.
         Query embedding will be automatically normalized if using GPU with COSINE.
@@ -262,7 +248,7 @@ class Vectorstore:
         k: int = kwargs.pop("k", 4)
         fetch_k: int = kwargs.pop("fetch_k", 20)
         lambda_mult: float = kwargs.pop("lambda_mult", 0.5)
-        filter_: Optional[Dict[str, Any]] = kwargs.pop("filter", None)
+        filter_: dict[str, Any] | None = kwargs.pop("filter", None)
 
         # Build Milvus expr from filter_, if present
         expr = None
@@ -272,9 +258,7 @@ class Vectorstore:
                 if isinstance(value, str):
                     conditions.append(f'{key} == "{value}"')
                 elif isinstance(value, list):
-                    vals = ", ".join(
-                        f'"{v}"' if isinstance(v, str) else str(v) for v in value
-                    )
+                    vals = ", ".join(f'"{v}"' if isinstance(v, str) else str(v) for v in value)
                     conditions.append(f"{key} in [{vals}]")
                 else:
                     conditions.append(f"{key} == {value}")
@@ -330,7 +314,7 @@ class Vectorstore:
         else:
             logger.info("Collection is empty, skipping load operation")
 
-    def get_embedding_info(self) -> Dict[str, Any]:
+    def get_embedding_info(self) -> dict[str, Any]:
         """Get information about the embedding configuration."""
         return {
             "has_gpu": self.has_gpu,

aiagents4pharma/talk2scholars/tools/s2/__init__.py

@@ -2,12 +2,14 @@
 This file is used to import all the modules in the package.
 """
 
-from . import display_dataframe
-from . import multi_paper_rec
-from . import search
-from . import single_paper_rec
-from . import query_dataframe
-from . import retrieve_semantic_scholar_paper_id
+from . import (
+    display_dataframe,
+    multi_paper_rec,
+    query_dataframe,
+    retrieve_semantic_scholar_paper_id,
+    search,
+    single_paper_rec,
+)
 
 __all__ = [
     "display_dataframe",

aiagents4pharma/talk2scholars/tools/s2/display_dataframe.py

@@ -12,17 +12,15 @@ only displays the existing list. If no papers are available, it raises NoPapersF
 to signal that a search or recommendation must be executed first.
 """
 
-
 import logging
-
 from typing import Annotated
-from pydantic import BaseModel, Field
+
 from langchain_core.messages import ToolMessage
 from langchain_core.tools import tool
 from langchain_core.tools.base import InjectedToolCallId
 from langgraph.prebuilt import InjectedState
 from langgraph.types import Command
-
+from pydantic import BaseModel, Field
 
 # Configure logging
 logging.basicConfig(level=logging.INFO)
@@ -97,9 +95,7 @@ def display_dataframe(
         artifact = state.get(context_val)
     if not artifact:
         logger.info("No papers found in state, raising NoPapersFoundError")
-        raise NoPapersFoundError(
-            "No papers found. A search/rec needs to be performed first."
-        )
+        raise NoPapersFoundError("No papers found. A search/rec needs to be performed first.")
     content = f"{len(artifact)} papers found. Papers are attached as an artifact."
     return Command(
         update={

aiagents4pharma/talk2scholars/tools/s2/multi_paper_rec.py

@@ -9,14 +9,15 @@ of recommended papers.
 """
 
 import logging
-from typing import Annotated, Any, List, Optional
+from typing import Annotated, Any
+
 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 BaseModel, Field
-from .utils.multi_helper import MultiPaperRecData
 
+from .utils.multi_helper import MultiPaperRecData
 
 # Configure logging
 logging.basicConfig(level=logging.INFO)
@@ -34,7 +35,7 @@ class MultiPaperRecInput(BaseModel):
         tool_call_id: Internal tool call identifier injected by the system.
     """
 
-    paper_ids: List[str] = Field(
+    paper_ids: list[str] = Field(
         description="List of 40-character Semantic Scholar Paper IDs"
         "(at least two) to base recommendations on"
     )
@@ -44,7 +45,7 @@ class MultiPaperRecInput(BaseModel):
         ge=1,
         le=500,
     )
-    year: Optional[str] = Field(
+    year: str | None = Field(
         default=None,
         description="Publication year filter; supports formats:"
         "'YYYY', 'YYYY-', '-YYYY', 'YYYY:YYYY'",
@@ -59,10 +60,10 @@ class MultiPaperRecInput(BaseModel):
     parse_docstring=True,
 )
 def get_multi_paper_recommendations(
-    paper_ids: List[str],
+    paper_ids: list[str],
     tool_call_id: Annotated[str, InjectedToolCallId],
     limit: int = 10,
-    year: Optional[str] = None,
+    year: str | None = None,
 ) -> Command[Any]:
     """
     Recommend related research papers using the Semantic Scholar API.