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

aiagents4pharma/talk2aiagents4pharma/states/state_talk2aiagents4pharma.py

@@ -3,10 +3,12 @@ This is the state file for the Talk2AIAgents4Pharma agent.
 """
 
 from ...talk2biomodels.states.state_talk2biomodels import Talk2Biomodels
-from ...talk2knowledgegraphs.states.state_talk2knowledgegraphs import Talk2KnowledgeGraphs
+from ...talk2knowledgegraphs.states.state_talk2knowledgegraphs import (
+    Talk2KnowledgeGraphs,
+)
 
-class Talk2AIAgents4Pharma(Talk2Biomodels,
-                           Talk2KnowledgeGraphs):
+
+class Talk2AIAgents4Pharma(Talk2Biomodels, Talk2KnowledgeGraphs):
     """
     The state for the Talk2AIAgents4Pharma agent.
 

aiagents4pharma/talk2aiagents4pharma/tests/__init__.py

@@ -1,3 +1,3 @@
-'''
+"""
 This module contains the test cases.
-'''
+"""

aiagents4pharma/talk2aiagents4pharma/tests/test_main_agent.py

@@ -1,17 +1,21 @@
-'''
+"""
 Test Talk2AIAgents4Pharma supervisor agent.
-'''
-from unittest.mock import patch, MagicMock
+"""
+
+from unittest.mock import MagicMock, patch
+
+import pandas as pd
 import pytest
 from langchain_core.messages import HumanMessage
 from langchain_openai import ChatOpenAI, OpenAIEmbeddings
-import pandas as pd
+
 from ..agents.main_agent import get_app
 
 # Define the data path for the test files of Talk2KnowledgeGraphs agent
 DATA_PATH = "aiagents4pharma/talk2knowledgegraphs/tests/files"
 LLM_MODEL = ChatOpenAI(model="gpt-4o-mini", temperature=0.0)
 
+
 @pytest.fixture(name="input_dict")
 def input_dict_fixture():
     """
@@ -27,7 +31,7 @@ def input_dict_fixture():
             "cellular_component": [],
             "biological_process": [],
             "drug": [],
-            "disease": []
+            "disease": [],
         },
         "uploaded_files": [],
         "dic_source_graph": [
@@ -37,43 +41,54 @@ def input_dict_fixture():
                 "kg_text_path": f"{DATA_PATH}/biobridge_multimodal_text_graph.pkl",
             }
         ],
-        "dic_extracted_graph": []
+        "dic_extracted_graph": [],
     }
 
     return input_dict
 
+
 def mock_milvus_collection(name):
     """
     Mock Milvus collection for testing.
     """
     nodes = MagicMock()
     nodes.query.return_value = [
-        {"node_index": 0,
-         "node_id": "id1",
-         "node_name": "Adalimumab",
-         "node_type": "drug",
-         "feat": "featA", "feat_emb": [0.1, 0.2, 0.3],
-         "desc": "descA", "desc_emb": [0.1, 0.2, 0.3]},
-        {"node_index": 1,
-         "node_id": "id2",
-         "node_name": "TNF",
-         "node_type": "gene/protein",
-         "feat": "featB", "feat_emb": [0.4, 0.5, 0.6], 
-         "desc": "descB", "desc_emb": [0.4, 0.5, 0.6]}
+        {
+            "node_index": 0,
+            "node_id": "id1",
+            "node_name": "Adalimumab",
+            "node_type": "drug",
+            "feat": "featA",
+            "feat_emb": [0.1, 0.2, 0.3],
+            "desc": "descA",
+            "desc_emb": [0.1, 0.2, 0.3],
+        },
+        {
+            "node_index": 1,
+            "node_id": "id2",
+            "node_name": "TNF",
+            "node_type": "gene/protein",
+            "feat": "featB",
+            "feat_emb": [0.4, 0.5, 0.6],
+            "desc": "descB",
+            "desc_emb": [0.4, 0.5, 0.6],
+        },
     ]
     nodes.load.return_value = None
 
     edges = MagicMock()
     edges.query.return_value = [
-        {"triplet_index": 0,
-         "head_id": "id1",
-         "head_index": 0,
-         "tail_id": "id2",
-         "tail_index": 1,
-         "edge_type": "drug,acts_on,gene/protein",
-         "display_relation": "acts_on",
-         "feat": "featC",
-         "feat_emb": [0.7, 0.8, 0.9]}
+        {
+            "triplet_index": 0,
+            "head_id": "id1",
+            "head_index": 0,
+            "tail_id": "id2",
+            "tail_index": 1,
+            "edge_type": "drug,acts_on,gene/protein",
+            "display_relation": "acts_on",
+            "feat": "featC",
+            "feat_emb": [0.7, 0.8, 0.9],
+        }
     ]
     edges.load.return_value = None
 
@@ -83,6 +98,7 @@ def mock_milvus_collection(name):
         return edges
     return None
 
+
 def test_main_agent_invokes_t2kg(input_dict):
     """
     In the following test, we will ask the main agent (supervisor)
@@ -109,21 +125,31 @@ def test_main_agent_invokes_t2kg(input_dict):
     )
     prompt = "List drugs that target the gene Interleukin-6"
 
-    with patch("aiagents4pharma.talk2knowledgegraphs.tools."
-               "milvus_multimodal_subgraph_extraction.Collection", 
-               side_effect=mock_milvus_collection), \
-         patch("aiagents4pharma.talk2knowledgegraphs.tools."
-               "milvus_multimodal_subgraph_extraction.MultimodalPCSTPruning") as mock_pcst, \
-         patch("pymilvus.connections") as mock_connections, \
-         patch("aiagents4pharma.talk2knowledgegraphs.tools."
-               "milvus_multimodal_subgraph_extraction.hydra.initialize"), \
-         patch("aiagents4pharma.talk2knowledgegraphs.tools."
-               "milvus_multimodal_subgraph_extraction.hydra.compose") as mock_compose:
+    with (
+        patch(
+            "aiagents4pharma.talk2knowledgegraphs.tools."
+            "milvus_multimodal_subgraph_extraction.Collection",
+            side_effect=mock_milvus_collection,
+        ),
+        patch(
+            "aiagents4pharma.talk2knowledgegraphs.tools."
+            "milvus_multimodal_subgraph_extraction.MultimodalPCSTPruning"
+        ) as mock_pcst,
+        patch("pymilvus.connections") as mock_connections,
+        patch(
+            "aiagents4pharma.talk2knowledgegraphs.tools."
+            "milvus_multimodal_subgraph_extraction.hydra.initialize"
+        ),
+        patch(
+            "aiagents4pharma.talk2knowledgegraphs.tools."
+            "milvus_multimodal_subgraph_extraction.hydra.compose"
+        ) as mock_compose,
+    ):
         mock_connections.has_connection.return_value = True
         mock_pcst_instance = MagicMock()
         mock_pcst_instance.extract_subgraph.return_value = {
             "nodes": pd.Series([0, 1]),
-            "edges": pd.Series([0])
+            "edges": pd.Series([0]),
         }
         mock_pcst.return_value = mock_pcst_instance
         mock_cfg = MagicMock()
@@ -137,14 +163,12 @@ def test_main_agent_invokes_t2kg(input_dict):
         mock_cfg.node_colors_dict = {"drug": "blue", "gene/protein": "red"}
         mock_compose.return_value = MagicMock()
         mock_compose.return_value.tools.multimodal_subgraph_extraction = mock_cfg
-        mock_compose.return_value.tools.subgraph_summarization.\
-            prompt_subgraph_summarization = (
+        mock_compose.return_value.tools.subgraph_summarization.prompt_subgraph_summarization = (
             "Summarize the following subgraph: {textualized_subgraph}"
         )
 
         # Invoke the agent
-        response = app.invoke({"messages": [HumanMessage(content=prompt)]},
-                              config=config)
+        response = app.invoke({"messages": [HumanMessage(content=prompt)]}, config=config)
 
     # Check assistant message
     assistant_msg = response["messages"][-1].content
@@ -168,23 +192,21 @@ def test_main_agent_invokes_t2kg(input_dict):
     result = mock_milvus_collection("unknown")
     assert result is None
 
+
 def test_main_agent_invokes_t2b():
-    '''
+    """
     In the following test, we will ask the main agent (supervisor)
     to simulate a model. And we will check if the Talk2BioModels
     agent is invoked. We will do so by checking the state of the
     Talk2AIAgents4Pharma agent, which is partly inherited from the
     Talk2BioModels agent.
-    '''
+    """
     unique_id = 123
     app = get_app(unique_id, llm_model=LLM_MODEL)
     config = {"configurable": {"thread_id": unique_id}}
     prompt = "Simulate model 64"
     # Invoke the agent
-    app.invoke(
-        {"messages": [HumanMessage(content=prompt)]},
-        config=config
-    )
+    app.invoke({"messages": [HumanMessage(content=prompt)]}, config=config)
     # Get the state of the Talk2AIAgents4Pharma agent
     current_state = app.get_state(config)
     # Check if the dic_simulated_data is in the state
@@ -194,7 +216,7 @@ def test_main_agent_invokes_t2b():
     # Check if the length of the dic_simulated_data is 1
     assert len(dic_simulated_data) == 1
     # Check if the source of the model is 64
-    assert dic_simulated_data[0]['source'] == 64
+    assert dic_simulated_data[0]["source"] == 64
     # Check if the data of the model contains
     # '1,3-bisphosphoglycerate'
-    assert '1,3-bisphosphoglycerate' in dic_simulated_data[0]['data']
+    assert "1,3-bisphosphoglycerate" in dic_simulated_data[0]["data"]

aiagents4pharma/talk2biomodels/.dockerignore

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

aiagents4pharma/talk2biomodels/Dockerfile

@@ -0,0 +1,104 @@
+# syntax=docker/dockerfile:1
+
+# Dockerfile for the talk2biomodels 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="talk2biomodels"
+LABEL version="1.0.0"
+LABEL description="AI Agents for Pharma - Biomodels 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/talk2biomodels /app/aiagents4pharma/talk2biomodels
+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_talk2biomodels.py", "--server.port=8501", "--server.address=0.0.0.0"]

aiagents4pharma/talk2biomodels/README.md

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

aiagents4pharma/talk2biomodels/__init__.py

@@ -1,9 +1,5 @@
-'''
+"""
 This file is used to import the models and tools.
-'''
-from . import models
-from . import tools
-from . import agents
-from . import states
-from . import api
-from . import configs
+"""
+
+from . import agents, api, configs, models, states, tools

aiagents4pharma/talk2biomodels/agents/__init__.py

@@ -1,5 +1,6 @@
-'''
+"""
 This file is used to import all the modules in the package.
-'''
+"""
+
 # import everything from the module
 from . import t2b_agent

aiagents4pharma/talk2biomodels/agents/t2b_agent.py

@@ -1,73 +1,77 @@
-#/usr/bin/env python3
+# /usr/bin/env python3
 
-'''
+"""
 This is the agent file for the Talk2BioModels agent.
-'''
+"""
 
 import logging
 from typing import Annotated
+
 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 import create_react_agent, ToolNode, InjectedState
-from ..tools.search_models import SearchModelsTool
-from ..tools.get_modelinfo import GetModelInfoTool
-from ..tools.simulate_model import SimulateModelTool
+from langgraph.prebuilt import InjectedState, ToolNode, create_react_agent
+
+from ..states.state_talk2biomodels import Talk2Biomodels
+from ..tools.ask_question import AskQuestionTool
 from ..tools.custom_plotter import CustomPlotterTool
 from ..tools.get_annotation import GetAnnotationTool
-from ..tools.ask_question import AskQuestionTool
+from ..tools.get_modelinfo import GetModelInfoTool
 from ..tools.parameter_scan import ParameterScanTool
-from ..tools.steady_state import SteadyStateTool
 from ..tools.query_article import QueryArticle
-from ..states.state_talk2biomodels import Talk2Biomodels
+from ..tools.search_models import SearchModelsTool
+from ..tools.simulate_model import SimulateModelTool
+from ..tools.steady_state import SteadyStateTool
 
 # Initialize logger
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-def get_app(uniq_id,
-            llm_model: BaseChatModel):
-    '''
+
+def get_app(uniq_id, llm_model: BaseChatModel):
+    """
     This function returns the langraph app.
-    '''
+    """
+
     def agent_t2b_node(state: Annotated[dict, InjectedState]):
-        '''
+        """
         This function calls the model.
-        '''
+        """
         logger.log(logging.INFO, "Calling t2b_agent node with thread_id %s", uniq_id)
         response = model.invoke(state, {"configurable": {"thread_id": uniq_id}})
         return response
 
     # Define the tools
-    tools = ToolNode([
-                    SimulateModelTool(),
-                    AskQuestionTool(),
-                    CustomPlotterTool(),
-                    SearchModelsTool(),
-                    GetModelInfoTool(),
-                    SteadyStateTool(),
-                    ParameterScanTool(),
-                    GetAnnotationTool(),
-                    QueryArticle()
-                ])
+    tools = ToolNode(
+        [
+            SimulateModelTool(),
+            AskQuestionTool(),
+            CustomPlotterTool(),
+            SearchModelsTool(),
+            GetModelInfoTool(),
+            SteadyStateTool(),
+            ParameterScanTool(),
+            GetAnnotationTool(),
+            QueryArticle(),
+        ]
+    )
 
     # Load hydra configuration
     logger.log(logging.INFO, "Load Hydra configuration for Talk2BioModels agent.")
     with hydra.initialize(version_base=None, config_path="../configs"):
-        cfg = hydra.compose(config_name='config',
-                            overrides=['agents/t2b_agent=default'])
+        cfg = hydra.compose(config_name="config", overrides=["agents/t2b_agent=default"])
         cfg = cfg.agents.t2b_agent
     logger.log(logging.INFO, "state_modifier: %s", cfg.state_modifier)
     # Create the agent
     model = create_react_agent(
-                llm_model,
-                tools=tools,
-                state_schema=Talk2Biomodels,
-                prompt=cfg.state_modifier,
-                version='v2',
-                checkpointer=MemorySaver()
-            )
+        llm_model,
+        tools=tools,
+        state_schema=Talk2Biomodels,
+        prompt=cfg.state_modifier,
+        version="v2",
+        checkpointer=MemorySaver(),
+    )
 
     # Define a new graph
     workflow = StateGraph(Talk2Biomodels)
@@ -87,11 +91,12 @@ def get_app(uniq_id,
     # meaning you can use it as you would any other runnable.
     # Note that we're (optionally) passing the memory
     # when compiling the graph
-    app = workflow.compile(checkpointer=checkpointer,
-                           name="T2B_Agent")
-    logger.log(logging.INFO,
-               "Compiled the graph with thread_id %s and llm_model %s",
-               uniq_id,
-               llm_model)
+    app = workflow.compile(checkpointer=checkpointer, name="T2B_Agent")
+    logger.log(
+        logging.INFO,
+        "Compiled the graph with thread_id %s and llm_model %s",
+        uniq_id,
+        llm_model,
+    )
 
     return app

aiagents4pharma/talk2biomodels/api/__init__.py

@@ -1,6 +1,5 @@
-'''
+"""
 This file is used to import the modules in the package.
-'''
-from . import uniprot
-from . import ols
-from . import kegg
+"""
+
+from . import kegg, ols, uniprot

aiagents4pharma/talk2biomodels/api/kegg.py

@@ -1,10 +1,12 @@
 """
 This module contains the API for fetching Kegg database
 """
+
 import re
-from typing import List, Dict
+
 import requests
 
+
 def fetch_from_api(base_url: str, query: str) -> str:
     """Fetch data from the given API endpoint."""
     try:
@@ -15,7 +17,8 @@ def fetch_from_api(base_url: str, query: str) -> str:
         print(f"Error fetching data for query {query}: {e}")
         return ""
 
-def fetch_kegg_names(ids: List[str], batch_size: int = 10) -> Dict[str, str]:
+
+def fetch_kegg_names(ids: list[str], batch_size: int = 10) -> dict[str, str]:
     """
     Fetch the names of multiple KEGG entries using the KEGG REST API in batches.
 
@@ -34,7 +37,7 @@ def fetch_kegg_names(ids: List[str], batch_size: int = 10) -> Dict[str, str]:
 
     # Process IDs in batches
     for i in range(0, len(ids), batch_size):
-        batch = ids[i:i + batch_size]
+        batch = ids[i : i + batch_size]
         query = "+".join(batch)
         entry_data = fetch_from_api(base_url, query)
 
@@ -45,17 +48,15 @@ def fetch_kegg_names(ids: List[str], batch_size: int = 10) -> Dict[str, str]:
             if not entry.strip():
                 continue
             lines = entry.strip().split("\n")
-            entry_line = next((line for line in lines
-                                if line.startswith("ENTRY")), None)
-            name_line = next((line for line in lines
-                                if line.startswith("NAME")), None)
+            entry_line = next((line for line in lines if line.startswith("ENTRY")), None)
+            name_line = next((line for line in lines if line.startswith("NAME")), None)
 
             # if not entry_line and not name_line:
             #     continue
             entry_id = entry_line.split()[1]
             # Split multiple names in the NAME field and clean them
             names = [
-                re.sub(r'[^a-zA-Z0-9\s]', '', name).strip()
+                re.sub(r"[^a-zA-Z0-9\s]", "", name).strip()
                 for name in name_line.replace("NAME", "").strip().split(";")
             ]
             # Join cleaned names into a single string
@@ -63,8 +64,10 @@ def fetch_kegg_names(ids: List[str], batch_size: int = 10) -> Dict[str, str]:
 
     return entry_name_map
 
-def fetch_kegg_annotations(data: List[Dict[str, str]],
-                           batch_size: int = 10) -> Dict[str, Dict[str, str]]:
+
+def fetch_kegg_annotations(
+    data: list[dict[str, str]], batch_size: int = 10
+) -> dict[str, dict[str, str]]:
     """Fetch KEGG entry descriptions grouped by database type."""
     grouped_data = {}
     for entry in data:
@@ -77,6 +80,7 @@ def fetch_kegg_annotations(data: List[Dict[str, str]],
 
     return results
 
+
 # def get_protein_name_or_label(data: List[Dict[str, str]],
 #                               batch_size: int = 10) -> Dict[str, Dict[str, str]]:
 #     """Fetch descriptions for KEGG-related identifiers."""

aiagents4pharma/talk2biomodels/api/ols.py

@@ -1,9 +1,10 @@
 """
 This module contains the API for fetching ols database
 """
-from typing import List, Dict
+
 import requests
 
+
 def fetch_from_ols(term: str) -> str:
     """
     Fetch the label for a single term from OLS.
@@ -19,23 +20,24 @@ def fetch_from_ols(term: str) -> str:
         base_url = f"https://www.ebi.ac.uk/ols4/api/ontologies/{ontology.lower()}/terms"
         params = {"obo_id": term}
         response = requests.get(
-            base_url,
-            params=params,
-            headers={"Accept": "application/json"},
-            timeout=10
+            base_url, params=params, headers={"Accept": "application/json"}, timeout=10
         )
         response.raise_for_status()
         data = response.json()
-        label = '-'
+        label = "-"
         # Extract and return the label
-        if "_embedded" in data and "terms" in data["_embedded"] \
-             and len(data["_embedded"]["terms"]) > 0:
+        if (
+            "_embedded" in data
+            and "terms" in data["_embedded"]
+            and len(data["_embedded"]["terms"]) > 0
+        ):
             label = data["_embedded"]["terms"][0].get("label", "Label not found")
         return label
     except (requests.exceptions.RequestException, KeyError, IndexError) as e:
         return f"Error: {str(e)}"
 
-def fetch_ols_labels(terms: List[str]) -> Dict[str, str]:
+
+def fetch_ols_labels(terms: list[str]) -> dict[str, str]:
     """
     Fetch labels for multiple terms from OLS.
 
@@ -50,7 +52,8 @@ def fetch_ols_labels(terms: List[str]) -> Dict[str, str]:
         results[term] = fetch_from_ols(term)
     return results
 
-def search_ols_labels(data: List[Dict[str, str]]) -> Dict[str, Dict[str, str]]:
+
+def search_ols_labels(data: list[dict[str, str]]) -> dict[str, dict[str, str]]:
     """
     Fetch OLS annotations grouped by ontology type.