aiagents4pharma 1.44.0__py3-none-any.whl → 1.45.1__py3-none-any.whl

aiagents4pharma/talk2knowledgegraphs/utils/extractions/multimodal_pcst.py

@@ -2,13 +2,15 @@
 Exctraction of multimodal subgraph using Prize-Collecting Steiner Tree (PCST) algorithm.
 """
 
-from typing import Tuple, NamedTuple
+from typing import NamedTuple
+
 import numpy as np
 import pandas as pd
-import torch
 import pcst_fast
+import torch
 from torch_geometric.data.data import Data
 
+
 class MultimodalPCSTPruning(NamedTuple):
     """
     Prize-Collecting Steiner Tree (PCST) pruning algorithm implementation inspired by G-Retriever
@@ -27,6 +29,7 @@ class MultimodalPCSTPruning(NamedTuple):
         pruning: The pruning strategy to use.
         verbosity_level: The verbosity level.
     """
+
     topk: int = 3
     topk_e: int = 3
     cost_e: float = 0.5
@@ -37,10 +40,7 @@ class MultimodalPCSTPruning(NamedTuple):
     verbosity_level: int = 0
     use_description: bool = False
 
-    def _compute_node_prizes(self,
-                             graph: Data,
-                             query_emb: torch.Tensor,
-                             modality: str) :
+    def _compute_node_prizes(self, graph: Data, query_emb: torch.Tensor, modality: str):
         """
         Compute the node prizes based on the cosine similarity between the query and nodes.
 
@@ -54,25 +54,28 @@ class MultimodalPCSTPruning(NamedTuple):
             The prizes of the nodes.
         """
         # Convert PyG graph to a DataFrame
-        graph_df = pd.DataFrame({
-            "node_type": graph.node_type,
-            "desc_x": [x.tolist() for x in graph.desc_x],
-            "x": [list(x) for x in graph.x],
-            "score": [0.0 for _ in range(len(graph.node_id))],
-        })
+        graph_df = pd.DataFrame(
+            {
+                "node_type": graph.node_type,
+                "desc_x": [x.tolist() for x in graph.desc_x],
+                "x": [list(x) for x in graph.x],
+                "score": [0.0 for _ in range(len(graph.node_id))],
+            }
+        )
 
         # Calculate cosine similarity for text features and update the score
         if self.use_description:
             graph_df.loc[:, "score"] = torch.nn.CosineSimilarity(dim=-1)(
-                    query_emb,
-                    torch.tensor(list(graph_df.desc_x.values)) # Using textual description features
-                ).tolist()
+                query_emb,
+                torch.tensor(list(graph_df.desc_x.values)),  # Using textual description features
+            ).tolist()
         else:
-            graph_df.loc[graph_df["node_type"] == modality,
-                         "score"] = torch.nn.CosineSimilarity(dim=-1)(
-                    query_emb,
-                    torch.tensor(list(graph_df[graph_df["node_type"]== modality].x.values))
-                ).tolist()
+            graph_df.loc[graph_df["node_type"] == modality, "score"] = torch.nn.CosineSimilarity(
+                dim=-1
+            )(
+                query_emb,
+                torch.tensor(list(graph_df[graph_df["node_type"] == modality].x.values)),
+            ).tolist()
 
         # Set the prizes for nodes based on the similarity scores
         n_prizes = torch.tensor(graph_df.score.values, dtype=torch.float32)
@@ -84,9 +87,7 @@ class MultimodalPCSTPruning(NamedTuple):
 
         return n_prizes
 
-    def _compute_edge_prizes(self,
-                             graph: Data,
-                             text_emb: torch.Tensor) :
+    def _compute_edge_prizes(self, graph: Data, text_emb: torch.Tensor):
         """
         Compute the node prizes based on the cosine similarity between the query and nodes.
 
@@ -106,20 +107,22 @@ class MultimodalPCSTPruning(NamedTuple):
         e_prizes[e_prizes < topk_e_values[-1]] = 0.0
         last_topk_e_value = topk_e
         for k in range(topk_e):
-            indices = inverse_indices == (
-                unique_prizes == topk_e_values[k]
-            ).nonzero(as_tuple=True)[0]
+            indices = (
+                inverse_indices == (unique_prizes == topk_e_values[k]).nonzero(as_tuple=True)[0]
+            )
             value = min((topk_e - k) / indices.sum().item(), last_topk_e_value)
             e_prizes[indices] = value
             last_topk_e_value = value * (1 - self.c_const)
 
         return e_prizes
 
-    def compute_prizes(self,
-                       graph: Data,
-                       text_emb: torch.Tensor,
-                       query_emb: torch.Tensor,
-                       modality: str):
+    def compute_prizes(
+        self,
+        graph: Data,
+        text_emb: torch.Tensor,
+        query_emb: torch.Tensor,
+        modality: str,
+    ):
         """
         Compute the node prizes based on the cosine similarity between the query and nodes,
         as well as the edge prizes based on the cosine similarity between the query and edges.
@@ -144,9 +147,9 @@ class MultimodalPCSTPruning(NamedTuple):
 
         return {"nodes": n_prizes, "edges": e_prizes}
 
-    def compute_subgraph_costs(self,
-                               graph: Data,
-                               prizes: dict) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
+    def compute_subgraph_costs(
+        self, graph: Data, prizes: dict
+    ) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
         """
         Compute the costs in constructing the subgraph proposed by G-Retriever paper.
 
@@ -204,7 +207,11 @@ class MultimodalPCSTPruning(NamedTuple):
         return edges_dict, prizes, costs, mapping
 
     def get_subgraph_nodes_edges(
-        self, graph: Data, vertices: np.ndarray, edges_dict: dict, mapping: dict,
+        self,
+        graph: Data,
+        vertices: np.ndarray,
+        edges_dict: dict,
+        mapping: dict,
     ) -> dict:
         """
         Get the selected nodes and edges of the subgraph based on the vertices and edges computed
@@ -234,18 +241,18 @@ class MultimodalPCSTPruning(NamedTuple):
             subgraph_edges = np.array(subgraph_edges + virtual_edges)
         edge_index = graph.edge_index[:, subgraph_edges]
         subgraph_nodes = np.unique(
-            np.concatenate(
-                [subgraph_nodes, edge_index[0].numpy(), edge_index[1].numpy()]
-            )
+            np.concatenate([subgraph_nodes, edge_index[0].numpy(), edge_index[1].numpy()])
         )
 
         return {"nodes": subgraph_nodes, "edges": subgraph_edges}
 
-    def extract_subgraph(self,
-                         graph: Data,
-                         text_emb: torch.Tensor,
-                         query_emb: torch.Tensor,
-                         modality: str) -> dict:
+    def extract_subgraph(
+        self,
+        graph: Data,
+        text_emb: torch.Tensor,
+        query_emb: torch.Tensor,
+        modality: str,
+    ) -> dict:
         """
         Perform the Prize-Collecting Steiner Tree (PCST) algorithm to extract the subgraph.
 
@@ -268,9 +275,7 @@ class MultimodalPCSTPruning(NamedTuple):
         prizes = self.compute_prizes(graph, text_emb, query_emb, modality)
 
         # Compute costs in constructing the subgraph
-        edges_dict, prizes, costs, mapping = self.compute_subgraph_costs(
-            graph, prizes
-        )
+        edges_dict, prizes, costs, mapping = self.compute_subgraph_costs(graph, prizes)
 
         # Retrieve the subgraph using the PCST algorithm
         result_vertices, result_edges = pcst_fast.pcst_fast(
@@ -287,6 +292,7 @@ class MultimodalPCSTPruning(NamedTuple):
             graph,
             result_vertices,
             {"edges": result_edges, "num_prior_edges": edges_dict["num_prior_edges"]},
-            mapping)
+            mapping,
+        )
 
         return subgraph

aiagents4pharma/talk2knowledgegraphs/utils/extractions/pcst.py

@@ -2,12 +2,14 @@
 Exctraction of subgraph using Prize-Collecting Steiner Tree (PCST) algorithm.
 """
 
-from typing import Tuple, NamedTuple
+from typing import NamedTuple
+
 import numpy as np
-import torch
 import pcst_fast
+import torch
 from torch_geometric.data.data import Data
 
+
 class PCSTPruning(NamedTuple):
     """
     Prize-Collecting Steiner Tree (PCST) pruning algorithm implementation inspired by G-Retriever
@@ -26,6 +28,7 @@ class PCSTPruning(NamedTuple):
         pruning: The pruning strategy to use.
         verbosity_level: The verbosity level.
     """
+
     topk: int = 3
     topk_e: int = 3
     cost_e: float = 0.5
@@ -76,9 +79,9 @@ class PCSTPruning(NamedTuple):
         e_prizes[e_prizes < topk_e_values[-1]] = 0.0
         last_topk_e_value = topk_e
         for k in range(topk_e):
-            indices = inverse_indices == (
-                unique_prizes == topk_e_values[k]
-            ).nonzero(as_tuple=True)[0]
+            indices = (
+                inverse_indices == (unique_prizes == topk_e_values[k]).nonzero(as_tuple=True)[0]
+            )
             value = min((topk_e - k) / indices.sum().item(), last_topk_e_value)
             e_prizes[indices] = value
             last_topk_e_value = value * (1 - self.c_const)
@@ -87,7 +90,7 @@ class PCSTPruning(NamedTuple):
 
     def compute_subgraph_costs(
         self, graph: Data, prizes: dict
-    ) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
+    ) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
         """
         Compute the costs in constructing the subgraph proposed by G-Retriever paper.
 
@@ -145,7 +148,11 @@ class PCSTPruning(NamedTuple):
         return edges_dict, prizes, costs, mapping
 
     def get_subgraph_nodes_edges(
-        self, graph: Data, vertices: np.ndarray, edges_dict: dict, mapping: dict,
+        self,
+        graph: Data,
+        vertices: np.ndarray,
+        edges_dict: dict,
+        mapping: dict,
     ) -> dict:
         """
         Get the selected nodes and edges of the subgraph based on the vertices and edges computed
@@ -175,9 +182,7 @@ class PCSTPruning(NamedTuple):
             subgraph_edges = np.array(subgraph_edges + virtual_edges)
         edge_index = graph.edge_index[:, subgraph_edges]
         subgraph_nodes = np.unique(
-            np.concatenate(
-                [subgraph_nodes, edge_index[0].numpy(), edge_index[1].numpy()]
-            )
+            np.concatenate([subgraph_nodes, edge_index[0].numpy(), edge_index[1].numpy()])
         )
 
         return {"nodes": subgraph_nodes, "edges": subgraph_edges}
@@ -201,9 +206,7 @@ class PCSTPruning(NamedTuple):
         prizes = self.compute_prizes(graph, query_emb)
 
         # Compute costs in constructing the subgraph
-        edges_dict, prizes, costs, mapping = self.compute_subgraph_costs(
-            graph, prizes
-        )
+        edges_dict, prizes, costs, mapping = self.compute_subgraph_costs(graph, prizes)
 
         # Retrieve the subgraph using the PCST algorithm
         result_vertices, result_edges = pcst_fast.pcst_fast(
@@ -220,6 +223,7 @@ class PCSTPruning(NamedTuple):
             graph,
             result_vertices,
             {"edges": result_edges, "num_prior_edges": edges_dict["num_prior_edges"]},
-            mapping)
+            mapping,
+        )
 
         return subgraph

aiagents4pharma/talk2knowledgegraphs/utils/kg_utils.py

@@ -1,12 +1,12 @@
 #!/usr/bin/env python3
 
-'''A utility module for knowledge graph operations'''
+"""A utility module for knowledge graph operations"""
 
-from typing import Tuple
 import networkx as nx
 import pandas as pd
 
-def kg_to_df_pandas(kg: nx.DiGraph) -> Tuple[pd.DataFrame, pd.DataFrame]:
+
+def kg_to_df_pandas(kg: nx.DiGraph) -> tuple[pd.DataFrame, pd.DataFrame]:
     """
     Convert a directed knowledge graph to a pandas DataFrame.
 
@@ -19,20 +19,17 @@ def kg_to_df_pandas(kg: nx.DiGraph) -> Tuple[pd.DataFrame, pd.DataFrame]:
     """
 
     # Create a pandas DataFrame of the nodes
-    df_nodes = pd.DataFrame.from_dict(kg.nodes, orient='index')
+    df_nodes = pd.DataFrame.from_dict(kg.nodes, orient="index")
 
     # Create a pandas DataFrame of the edges
-    df_edges = nx.to_pandas_edgelist(kg,
-                                    source='node_source',
-                                    target='node_target')
+    df_edges = nx.to_pandas_edgelist(kg, source="node_source", target="node_target")
 
     return df_nodes, df_edges
 
-def df_pandas_to_kg(df: pd.DataFrame,
-                    df_nodes_attrs: pd.DataFrame,
-                    node_source: str,
-                    node_target: str
-                    ) -> nx.DiGraph:
+
+def df_pandas_to_kg(
+    df: pd.DataFrame, df_nodes_attrs: pd.DataFrame, node_source: str, node_target: str
+) -> nx.DiGraph:
     """
     Convert a pandas DataFrame to a directed knowledge graph.
 
@@ -47,22 +44,24 @@ def df_pandas_to_kg(df: pd.DataFrame,
     """
 
     # Assert if the columns node_source and node_target are in the df
-    assert node_source in df.columns, f'{node_source} not in df'
-    assert node_target in df.columns, f'{node_target} not in df'
+    assert node_source in df.columns, f"{node_source} not in df"
+    assert node_target in df.columns, f"{node_target} not in df"
 
     # Assert that the nodes in the index of the df_nodes_attrs
     # are present in the source and target columns of the df
-    assert set(df_nodes_attrs.index).issubset(set(df[node_source]).\
-                                        union(set(df[node_target]))), \
-                                        'Nodes in index of df_nodes not found in df_edges'
+    assert set(df_nodes_attrs.index).issubset(set(df[node_source]).union(set(df[node_target]))), (
+        "Nodes in index of df_nodes not found in df_edges"
+    )
 
     # Create a knowledge graph from the dataframes
     # Add edges and nodes to the knowledge graph
-    kg = nx.from_pandas_edgelist(df,
-                                source=node_source,
-                                target=node_target,
-                                create_using=nx.DiGraph,
-                                edge_attr=True)
-    kg.add_nodes_from(df_nodes_attrs.to_dict('index').items())
+    kg = nx.from_pandas_edgelist(
+        df,
+        source=node_source,
+        target=node_target,
+        create_using=nx.DiGraph,
+        edge_attr=True,
+    )
+    kg.add_nodes_from(df_nodes_attrs.to_dict("index").items())
 
     return kg

aiagents4pharma/talk2knowledgegraphs/utils/pubchem_utils.py

@@ -5,13 +5,15 @@ Enrichment class for enriching PubChem IDs with their STRINGS representation.
 """
 
 import logging
-import requests
+
 import hydra
+import requests
 
 # Initialize logger
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
+
 def cas_rn2pubchem_cid(casrn):
     """
     Convert CAS RN to PubChem CID.
@@ -24,8 +26,7 @@ def cas_rn2pubchem_cid(casrn):
     """
     # Load Hydra configuration for PubChem ID conversion
     with hydra.initialize(version_base=None, config_path="../configs"):
-        cfg = hydra.compose(config_name='config',
-                            overrides=['utils/pubchem_utils=default'])
+        cfg = hydra.compose(config_name="config", overrides=["utils/pubchem_utils=default"])
         cfg = cfg.utils.pubchem_utils
     # Prepare the URL
     pubchem_url_for_drug = f"{cfg.pubchem_casrn2cid_url}{casrn}/record/JSON"
@@ -43,6 +44,7 @@ def cas_rn2pubchem_cid(casrn):
             break
     return cid
 
+
 def external_id2pubchem_cid(db, db_id):
     """
     Convert external DB ID to PubChem CID.
@@ -59,8 +61,7 @@ def external_id2pubchem_cid(db, db_id):
     """
     # Load Hydra configuration for PubChem ID conversion
     with hydra.initialize(version_base=None, config_path="../configs"):
-        cfg = hydra.compose(config_name='config',
-                            overrides=['utils/pubchem_utils=default'])
+        cfg = hydra.compose(config_name="config", overrides=["utils/pubchem_utils=default"])
         cfg = cfg.utils.pubchem_utils
     # Prepare the URL
     pubchem_url_for_drug = f"{cfg.pubchem_cid_base_url}/{db}/{db_id}/JSON"
@@ -76,6 +77,7 @@ def external_id2pubchem_cid(db, db_id):
                 break
     return cid
 
+
 def pubchem_cid_description(cid):
     """
     Get the description of a PubChem CID.
@@ -88,8 +90,7 @@ def pubchem_cid_description(cid):
     """
     # Load Hydra configuration for PubChem CID description
     with hydra.initialize(version_base=None, config_path="../configs"):
-        cfg = hydra.compose(config_name='config',
-                            overrides=['utils/pubchem_utils=default'])
+        cfg = hydra.compose(config_name="config", overrides=["utils/pubchem_utils=default"])
         cfg = cfg.utils.pubchem_utils
     # Prepare the URL
     pubchem_url_for_descpription = f"{cfg.pubchem_cid_description_url}/{cid}/description/JSON"
@@ -97,7 +98,7 @@ def pubchem_cid_description(cid):
     response = requests.get(pubchem_url_for_descpription, timeout=60)
     data = response.json()
     # Extract the PubChem CID description
-    description = ''
-    for information in data["InformationList"]['Information']:
-        description += information.get("Description", '')
+    description = ""
+    for information in data["InformationList"]["Information"]:
+        description += information.get("Description", "")
     return description

aiagents4pharma/talk2scholars/.dockerignore

@@ -0,0 +1,13 @@
+_pycache_/
+*.pyc
+*.log
+*.csv
+*.pt
+*.pkl
+models/
+data/
+env/
+.venv/
+.git/
+.env
+.cufile.log

aiagents4pharma/talk2scholars/Dockerfile

@@ -0,0 +1,104 @@
+# syntax=docker/dockerfile:1
+
+# Dockerfile for the talk2scholars application
+# Multi-stage build for optimized image size with UV package manager
+
+ARG BASE_IMAGE=ubuntu:24.04
+ARG PYTHON_VERSION=3.12
+
+FROM ${BASE_IMAGE} AS dev-base
+RUN apt-get update && DEBIAN_FRONTEND=noninteractive apt-get install -y --no-install-recommends \
+  build-essential \
+  ca-certificates \
+  cmake \
+  curl \
+  g++ \
+  libopenblas-dev \
+  libomp-dev \
+  ninja-build \
+  wget \
+  && rm -rf /var/lib/apt/lists/*
+
+FROM dev-base AS python-install
+ARG PYTHON_VERSION=3.12
+
+# Install Python (available in Ubuntu 24.04 default repos)
+RUN apt-get update && DEBIAN_FRONTEND=noninteractive apt-get install -y --no-install-recommends \
+  python${PYTHON_VERSION} \
+  python${PYTHON_VERSION}-dev \
+  python${PYTHON_VERSION}-venv \
+  python3-pip \
+  && rm -rf /var/lib/apt/lists/* \
+  && update-alternatives --install /usr/bin/python3 python3 /usr/bin/python${PYTHON_VERSION} 1 \
+  && update-alternatives --install /usr/bin/python python /usr/bin/python${PYTHON_VERSION} 1
+
+FROM python-install AS uv-install
+WORKDIR /app
+
+# Install UV package manager and dependencies
+COPY pyproject.toml uv.lock* ./
+RUN curl -LsSf https://astral.sh/uv/install.sh | sh && \
+  export PATH="/root/.local/bin:$PATH" && \
+  export UV_PROJECT_ENVIRONMENT="/opt/venv" && \
+  uv sync --frozen --extra dev --no-install-project --python python${PYTHON_VERSION} && \
+  . /opt/venv/bin/activate && \
+  # RAPIDS packages (commented out - will be added in future if needed)
+  # uv pip install \
+  # --extra-index-url=https://pypi.nvidia.com \
+  # --index-strategy unsafe-best-match \
+  # cudf-cu12 dask-cudf-cu12 && \
+  uv cache clean
+
+FROM ${BASE_IMAGE} AS runtime
+ARG PYTHON_VERSION=3.12
+LABEL maintainer="talk2scholars"
+LABEL version="1.0.0"
+LABEL description="AI Agents for Pharma - Scholars Application"
+
+# Install runtime dependencies
+RUN apt-get update && DEBIAN_FRONTEND=noninteractive apt-get install -y --no-install-recommends \
+  ca-certificates \
+  curl \
+  libmagic1 \
+  libopenblas0 \
+  libomp5 \
+  python${PYTHON_VERSION} \
+  && rm -rf /var/lib/apt/lists/* \
+  && update-alternatives --install /usr/bin/python3 python3 /usr/bin/python${PYTHON_VERSION} 1 \
+  && update-alternatives --install /usr/bin/python python /usr/bin/python${PYTHON_VERSION} 1
+
+# Copy UV virtual environment from build stage
+COPY --from=uv-install /opt/venv /opt/venv
+
+# Set environment variables
+ENV PATH="/opt/venv/bin:$PATH"
+ENV PYTHONPATH="/app"
+ENV PYTHONUNBUFFERED=1
+ENV PYTHONDONTWRITEBYTECODE=1
+ENV STREAMLIT_SERVER_HEADLESS=true
+ENV STREAMLIT_SERVER_ENABLE_CORS=false
+
+# Set working directory and create necessary directories
+WORKDIR /app
+
+# Copy application code
+COPY aiagents4pharma/talk2scholars /app/aiagents4pharma/talk2scholars
+COPY docs /app/docs
+COPY app /app/app
+
+# Copy and set up the entrypoint script (commented out - will be added in future if needed)
+# COPY aiagents4pharma/talk2knowledgegraphs/entrypoint.sh /usr/local/bin/entrypoint.sh
+# RUN chmod +x /usr/local/bin/entrypoint.sh
+
+# Health check for production monitoring
+HEALTHCHECK --interval=30s --timeout=10s --start-period=60s --retries=3 \
+  CMD curl -f http://localhost:8501/health || exit 1
+
+# Expose the default Streamlit port
+EXPOSE 8501
+
+# Set the entrypoint (commented out - will be added in future if needed)
+# ENTRYPOINT ["/usr/local/bin/entrypoint.sh"]
+
+# Default command (can be overridden)
+CMD ["streamlit", "run", "/app/app/frontend/streamlit_app_talk2scholars.py", "--server.port=8501", "--server.address=0.0.0.0"]

aiagents4pharma/talk2scholars/README.md

@@ -0,0 +1 @@
+Please check out the README file in the root folder for more information.

aiagents4pharma/talk2scholars/agents/__init__.py

@@ -2,11 +2,7 @@
 This file is used to import all the modules in the package.
 """
 
-from . import main_agent
-from . import s2_agent
-from . import paper_download_agent
-from . import zotero_agent
-from . import pdf_agent
+from . import main_agent, paper_download_agent, pdf_agent, s2_agent, zotero_agent
 
 __all__ = [
     "main_agent",

aiagents4pharma/talk2scholars/agents/main_agent.py

@@ -12,15 +12,17 @@ Functions:
 """
 
 import logging
+
 import hydra
-from langgraph_supervisor import create_supervisor
-from langchain_openai import ChatOpenAI
 from langchain_core.language_models.chat_models import BaseChatModel
+from langchain_openai import ChatOpenAI
 from langgraph.checkpoint.memory import MemorySaver
+from langgraph_supervisor import create_supervisor
+
+from ..agents.paper_download_agent import get_app as get_app_paper_download
+from ..agents.pdf_agent import get_app as get_app_pdf
 from ..agents.s2_agent import get_app as get_app_s2
 from ..agents.zotero_agent import get_app as get_app_zotero
-from ..agents.pdf_agent import get_app as get_app_pdf
-from ..agents.paper_download_agent import get_app as get_app_paper_download
 from ..state.state_talk2scholars import Talk2Scholars
 
 # Initialize logger

aiagents4pharma/talk2scholars/agents/paper_download_agent.py

@@ -5,17 +5,18 @@ paper details and PDFs. It is part of the Talk2Scholars project.
 """
 
 import logging
-from typing import Any, Dict
+from typing import Any
+
 import hydra
 from langchain_core.language_models.chat_models import BaseChatModel
+from langgraph.checkpoint.memory import MemorySaver
 from langgraph.graph import START, StateGraph
 from langgraph.prebuilt.chat_agent_executor import create_react_agent
 from langgraph.prebuilt.tool_node import ToolNode
-from langgraph.checkpoint.memory import MemorySaver
+
 from ..state.state_talk2scholars import Talk2Scholars
 from ..tools.paper_download.paper_downloader import download_papers
 
-
 # Initialize logger
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
@@ -67,7 +68,7 @@ def get_app(uniq_id, llm_model: BaseChatModel):
         checkpointer=MemorySaver(),
     )
 
-    def paper_download_agent_node(state: Talk2Scholars) -> Dict[str, Any]:
+    def paper_download_agent_node(state: Talk2Scholars) -> dict[str, Any]:
         """
         Processes the current state to fetch the research paper from arXiv, BioRxiv, or MedRxiv.
         """

aiagents4pharma/talk2scholars/agents/pdf_agent.py

@@ -12,11 +12,13 @@ Usage:
 """
 
 import logging
+
 import hydra
 from langchain_core.language_models.chat_models import BaseChatModel
-from langgraph.graph import START, StateGraph
-from langgraph.prebuilt import create_react_agent, ToolNode
 from langgraph.checkpoint.memory import MemorySaver
+from langgraph.graph import START, StateGraph
+from langgraph.prebuilt import ToolNode, create_react_agent
+
 from ..state.state_talk2scholars import Talk2Scholars
 from ..tools.pdf.question_and_answer import question_and_answer
 

aiagents4pharma/talk2scholars/agents/s2_agent.py

@@ -5,7 +5,7 @@ Agent for interacting with Semantic Scholar
 """
 
 import logging
-from typing import Any, Dict
+from typing import Any
 
 import hydra
 from langchain_core.language_models.chat_models import BaseChatModel
@@ -54,7 +54,7 @@ def get_app(uniq_id, llm_model: BaseChatModel):
         >>> result = app.invoke(initial_state)
     """
 
-    def s2_agent_node(state: Talk2Scholars) -> Dict[str, Any]:
+    def s2_agent_node(state: Talk2Scholars) -> dict[str, Any]:
         """
         Processes the user query and retrieves relevant research papers.