aiagents4pharma 1.39.4__py3-none-any.whl → 1.40.0__py3-none-any.whl

aiagents4pharma/talk2knowledgegraphs/utils/extractions/milvus_multimodal_pcst.py

@@ -0,0 +1,393 @@
+"""
+Exctraction of multimodal subgraph using Prize-Collecting Steiner Tree (PCST) algorithm.
+"""
+
+from typing import Tuple, NamedTuple
+import logging
+import pickle
+import pandas as pd
+import pcst_fast
+from pymilvus import Collection
+try:
+    import cupy as py
+    import cudf
+    df = cudf
+except ImportError:
+    import numpy as py
+    df = pd
+
+# Initialize logger
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class MultimodalPCSTPruning(NamedTuple):
+    """
+    Prize-Collecting Steiner Tree (PCST) pruning algorithm implementation inspired by G-Retriever
+    (He et al., 'G-Retriever: Retrieval-Augmented Generation for Textual Graph Understanding and
+    Question Answering', NeurIPS 2024) paper.
+    https://arxiv.org/abs/2402.07630
+    https://github.com/XiaoxinHe/G-Retriever/blob/main/src/dataset/utils/retrieval.py
+
+    Args:
+        topk: The number of top nodes to consider.
+        topk_e: The number of top edges to consider.
+        cost_e: The cost of the edges.
+        c_const: The constant value for the cost of the edges computation.
+        root: The root node of the subgraph, -1 for unrooted.
+        num_clusters: The number of clusters.
+        pruning: The pruning strategy to use.
+        verbosity_level: The verbosity level.
+    """
+    topk: int = 3
+    topk_e: int = 3
+    cost_e: float = 0.5
+    c_const: float = 0.01
+    root: int = -1
+    num_clusters: int = 1
+    pruning: str = "gw"
+    verbosity_level: int = 0
+    use_description: bool = False
+    metric_type: str = "IP"  # Inner Product
+
+    def prepare_collections(self, cfg: dict, modality: str) -> dict:
+        """
+        Prepare the collections for nodes, node-type specific nodes, and edges in Milvus.
+
+        Args:
+            cfg: The configuration dictionary containing the Milvus setup.
+            modality: The modality to use for the subgraph extraction.
+
+        Returns:
+            A dictionary containing the collections of nodes, node-type specific nodes, and edges.
+        """
+        # Initialize the collections dictionary
+        colls = {}
+
+        # Load the collection for nodes
+        colls["nodes"] = Collection(name=f"{cfg.milvus_db.database_name}_nodes")
+
+        if modality != "prompt":
+            # Load the collection for the specific node type
+            colls["nodes_type"] = Collection(
+                f"{cfg.milvus_db.database_name}_nodes_{modality.replace('/', '_')}"
+            )
+
+        # Load the collection for edges
+        colls["edges"] = Collection(name=f"{cfg.milvus_db.database_name}_edges")
+
+        # Load the collections
+        for coll in colls.values():
+            coll.load()
+
+        return colls
+
+    def _compute_node_prizes(self,
+                             query_emb: list,
+                             colls: dict) -> dict:
+        """
+        Compute the node prizes based on the cosine similarity between the query and nodes.
+
+        Args:
+            query_emb: The query embedding. This can be an embedding of
+                a prompt, sequence, or any other feature to be used for the subgraph extraction.
+            colls: The collections of nodes, node-type specific nodes, and edges in Milvus.
+
+        Returns:
+            The prizes of the nodes.
+        """
+        # Intialize several variables
+        topk = min(self.topk, colls["nodes"].num_entities)
+        n_prizes = py.zeros(colls["nodes"].num_entities, dtype=py.float32)
+
+        # Calculate cosine similarity for text features and update the score
+        if self.use_description:
+            # Search the collection with the text embedding
+            res = colls["nodes"].search(
+                data=[query_emb],
+                anns_field="desc_emb",
+                param={"metric_type": self.metric_type},
+                limit=topk,
+                output_fields=["node_id"])
+        else:
+            # Search the collection with the query embedding
+            res = colls["nodes_type"].search(
+                data=[query_emb],
+                anns_field="feat_emb",
+                param={"metric_type": self.metric_type},
+                limit=topk,
+                output_fields=["node_id"])
+
+        # Update the prizes based on the search results
+        n_prizes[[r.id for r in res[0]]] = py.arange(topk, 0, -1).astype(py.float32)
+
+        return n_prizes
+
+    def _compute_edge_prizes(self,
+                             text_emb: list,
+                             colls: dict) -> py.ndarray:
+        """
+        Compute the node prizes based on the cosine similarity between the query and nodes.
+
+        Args:
+            text_emb: The textual description embedding.
+            colls: The collections of nodes, node-type specific nodes, and edges in Milvus.
+
+        Returns:
+            The prizes of the nodes.
+        """
+        # Intialize several variables
+        topk_e = min(self.topk_e, colls["edges"].num_entities)
+        e_prizes = py.zeros(colls["edges"].num_entities, dtype=py.float32)
+
+        # Search the collection with the query embedding
+        res = colls["edges"].search(
+            data=[text_emb],
+            anns_field="feat_emb",
+            param={"metric_type": self.metric_type},
+            limit=topk_e, # Only retrieve the top-k edges
+            # limit=colls["edges"].num_entities,
+            output_fields=["head_id", "tail_id"])
+
+        # Update the prizes based on the search results
+        e_prizes[[r.id for r in res[0]]] = [r.score for r in res[0]]
+
+        # Further process the edge_prizes
+        unique_prizes, inverse_indices = py.unique(e_prizes, return_inverse=True)
+        topk_e_values = unique_prizes[py.argsort(-unique_prizes)[:topk_e]]
+        # 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()[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,
+                       text_emb: list,
+                       query_emb: list,
+                       colls: dict) -> dict:
+        """
+        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.
+        Note that the node and edge embeddings shall use the same embedding model and dimensions
+        with the query.
+
+        Args:
+            text_emb: The textual description embedding.
+            query_emb: The query embedding. This can be an embedding of
+                a prompt, sequence, or any other feature to be used for the subgraph extraction.
+            colls: The collections of nodes, node-type specific nodes, and edges in Milvus.
+
+        Returns:
+            The prizes of the nodes and edges.
+        """
+        # Compute prizes for nodes
+        logger.log(logging.INFO, "_compute_node_prizes")
+        n_prizes = self._compute_node_prizes(query_emb, colls)
+
+        # Compute prizes for edges
+        logger.log(logging.INFO, "_compute_edge_prizes")
+        e_prizes = self._compute_edge_prizes(text_emb, colls)
+
+        return {"nodes": n_prizes, "edges": e_prizes}
+
+    def compute_subgraph_costs(self,
+                               edge_index: py.ndarray,
+                               num_nodes: int,
+                               prizes: dict) -> Tuple[py.ndarray, py.ndarray, py.ndarray]:
+        """
+        Compute the costs in constructing the subgraph proposed by G-Retriever paper.
+
+        Args:
+            edge_index: The edge index of the graph, consisting of source and destination nodes.
+            num_nodes: The number of nodes in the graph.
+            prizes: The prizes of the nodes and the edges.
+
+        Returns:
+            edges: The edges of the subgraph, consisting of edges and number of edges without
+                virtual edges.
+            prizes: The prizes of the subgraph.
+            costs: The costs of the subgraph.
+        """
+        # Initialize several variables
+        real_ = {}
+        virt_ = {}
+
+        # Update edge cost threshold
+        updated_cost_e = min(
+            self.cost_e,
+            py.max(prizes["edges"]).item() * (1 - self.c_const / 2),
+        )
+
+        # Masks for real and virtual edges
+        logger.log(logging.INFO, "Creating masks for real and virtual edges")
+        real_["mask"] = prizes["edges"] <= updated_cost_e
+        virt_["mask"] = ~real_["mask"]
+
+        # Real edge indices
+        logger.log(logging.INFO, "Computing real edges")
+        real_["indices"] = py.nonzero(real_["mask"])[0]
+        real_["src"] = edge_index[0][real_["indices"]]
+        real_["dst"] = edge_index[1][real_["indices"]]
+        real_["edges"] = py.stack([real_["src"], real_["dst"]], axis=1)
+        real_["costs"] = updated_cost_e - prizes["edges"][real_["indices"]]
+
+        # Edge index mapping: local real edge idx -> original global index
+        logger.log(logging.INFO, "Creating mapping for real edges")
+        mapping_edges = dict(zip(range(len(real_["indices"])), real_["indices"].tolist()))
+
+        # Virtual edge handling
+        logger.log(logging.INFO, "Computing virtual edges")
+        virt_["indices"] = py.nonzero(virt_["mask"])[0]
+        virt_["src"] = edge_index[0][virt_["indices"]]
+        virt_["dst"] = edge_index[1][virt_["indices"]]
+        virt_["prizes"] = prizes["edges"][virt_["indices"]] - updated_cost_e
+
+        # Generate virtual node IDs
+        logger.log(logging.INFO, "Generating virtual node IDs")
+        virt_["num"] = virt_["indices"].shape[0]
+        virt_["node_ids"] = py.arange(num_nodes, num_nodes + virt_["num"])
+
+        # Virtual edges: (src → virtual), (virtual → dst)
+        logger.log(logging.INFO, "Creating virtual edges")
+        virt_["edges_1"] = py.stack([virt_["src"], virt_["node_ids"]], axis=1)
+        virt_["edges_2"] = py.stack([virt_["node_ids"], virt_["dst"]], axis=1)
+        virt_["edges"] = py.concatenate([virt_["edges_1"],
+                                         virt_["edges_2"]], axis=0)
+        virt_["costs"] = py.zeros((virt_["edges"].shape[0],), dtype=real_["costs"].dtype)
+
+        # Combine real and virtual edges/costs
+        logger.log(logging.INFO, "Combining real and virtual edges/costs")
+        all_edges = py.concatenate([real_["edges"], virt_["edges"]], axis=0)
+        all_costs = py.concatenate([real_["costs"], virt_["costs"]], axis=0)
+
+        # Final prizes
+        logger.log(logging.INFO, "Getting final prizes")
+        final_prizes = py.concatenate([prizes["nodes"], virt_["prizes"]], axis=0)
+
+        # Mapping virtual node ID -> edge index in original graph
+        logger.log(logging.INFO, "Creating mapping for virtual nodes")
+        mapping_nodes = dict(zip(virt_["node_ids"].tolist(), virt_["indices"].tolist()))
+
+        # Build return values
+        logger.log(logging.INFO, "Building return values")
+        edges_dict = {
+            "edges": all_edges,
+            "num_prior_edges": real_["edges"].shape[0],
+        }
+        mapping = {
+            "edges": mapping_edges,
+            "nodes": mapping_nodes,
+        }
+
+        return edges_dict, final_prizes, all_costs, mapping
+
+    def get_subgraph_nodes_edges(self,
+                                 num_nodes: int,
+                                 vertices: py.ndarray,
+                                 edges_dict: dict,
+                                 mapping: dict) -> dict:
+        """
+        Get the selected nodes and edges of the subgraph based on the vertices and edges computed
+        by the PCST algorithm.
+
+        Args:
+            num_nodes: The number of nodes in the graph.
+            vertices: The vertices selected by the PCST algorithm.
+            edges_dict: A dictionary containing the edges and the number of prior edges.
+            mapping: A dictionary containing the mapping of nodes and edges.
+
+        Returns:
+            The selected nodes and edges of the extracted subgraph.
+        """
+        # Get edges information
+        edges = edges_dict["edges"]
+        num_prior_edges = edges_dict["num_prior_edges"]
+        # Get edges information
+        edges = edges_dict["edges"]
+        num_prior_edges = edges_dict["num_prior_edges"]
+        # Retrieve the selected nodes and edges based on the given vertices and edges
+        subgraph_nodes = vertices[vertices < num_nodes]
+        subgraph_edges = [mapping["edges"][e.item()] for e in edges if e < num_prior_edges]
+        virtual_vertices = vertices[vertices >= num_nodes]
+        if len(virtual_vertices) > 0:
+            virtual_vertices = vertices[vertices >= num_nodes]
+            virtual_edges = [mapping["nodes"][i.item()] for i in virtual_vertices]
+            subgraph_edges = py.array(subgraph_edges + virtual_edges)
+        edge_index = edges_dict["edge_index"][:, subgraph_edges]
+        subgraph_nodes = py.unique(
+            py.concatenate(
+                [subgraph_nodes, edge_index[0], edge_index[1]]
+            )
+        )
+
+        return {"nodes": subgraph_nodes, "edges": subgraph_edges}
+
+    def extract_subgraph(self,
+                         text_emb: list,
+                         query_emb: list,
+                         modality: str,
+                         cfg: dict) -> dict:
+        """
+        Perform the Prize-Collecting Steiner Tree (PCST) algorithm to extract the subgraph.
+
+        Args:
+            text_emb: The textual description embedding.
+            query_emb: The query embedding. This can be an embedding of
+                a prompt, sequence, or any other feature to be used for the subgraph extraction.
+            modality: The modality to use for the subgraph extraction
+                (e.g., "text", "sequence", "smiles").
+            cfg: The configuration dictionary containing the Milvus setup.
+
+        Returns:
+            The selected nodes and edges of the subgraph.
+        """
+        # Load the collections for nodes
+        logger.log(logging.INFO, "Preparing collections")
+        colls = self.prepare_collections(cfg, modality)
+
+        # Load cache edge index
+        logger.log(logging.INFO, "Loading cache edge index")
+        with open(cfg.milvus_db.cache_edge_index_path, "rb") as f:
+            edge_index = pickle.load(f)
+            edge_index = py.array(edge_index)
+
+        # Assert the topk and topk_e values for subgraph retrieval
+        assert self.topk > 0, "topk must be greater than or equal to 0"
+        assert self.topk_e > 0, "topk_e must be greater than or equal to 0"
+
+        # Retrieve the top-k nodes and edges based on the query embedding
+        logger.log(logging.INFO, "compute_prizes")
+        prizes = self.compute_prizes(text_emb, query_emb, colls)
+
+        # Compute costs in constructing the subgraph
+        logger.log(logging.INFO, "compute_subgraph_costs")
+        edges_dict, prizes, costs, mapping = self.compute_subgraph_costs(
+            edge_index, colls["nodes"].num_entities, prizes)
+
+        # Retrieve the subgraph using the PCST algorithm
+        logger.log(logging.INFO, "Running PCST algorithm")
+        result_vertices, result_edges = pcst_fast.pcst_fast(
+            edges_dict["edges"].tolist(),
+            prizes.tolist(),
+            costs.tolist(),
+            self.root,
+            self.num_clusters,
+            self.pruning,
+            self.verbosity_level,
+        )
+
+        # Get subgraph nodes and edges based on the result of the PCST algorithm
+        logger.log(logging.INFO, "Getting subgraph nodes and edges")
+        subgraph = self.get_subgraph_nodes_edges(
+            colls["nodes"].num_entities,
+            py.asarray(result_vertices),
+            {"edges": py.asarray(result_edges),
+             "num_prior_edges": edges_dict["num_prior_edges"],
+             "edge_index": edge_index},
+            mapping)
+        print(subgraph)
+
+        return subgraph

aiagents4pharma/talk2knowledgegraphs/utils/pubchem_utils.py

@@ -12,6 +12,37 @@ import hydra
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
+def cas_rn2pubchem_cid(casrn):
+    """
+    Convert CAS RN to PubChem CID.
+
+    Args:
+        casrn: The CAS RN of the drug.
+
+    Returns:
+        The PubChem CID of the drug.
+    """
+    # 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 = cfg.utils.pubchem_utils
+    # Prepare the URL
+    pubchem_url_for_drug = f"{cfg.pubchem_casrn2cid_url}{casrn}/record/JSON"
+    # Get the data
+    response = requests.get(pubchem_url_for_drug, timeout=60)
+    data = response.json()
+    # Extract the PubChem CID
+    cid = None
+    for substance in data.get("PC_Substances", []):
+        for compound in substance.get("compound", []):
+            if "id" in compound and "type" in compound["id"] and compound["id"]["type"] == 1:
+                cid = compound["id"].get("id", {}).get("cid")
+                break
+        if cid is not None:
+            break
+    return cid
+
 def external_id2pubchem_cid(db, db_id):
     """
     Convert external DB ID to PubChem CID.
@@ -26,7 +57,7 @@ def external_id2pubchem_cid(db, db_id):
     Returns:
         The PubChem CID of the drug.
     """
-    logger.log(logging.INFO, "Load Hydra configuration for PubChem ID conversion.")
+    # 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'])
@@ -55,7 +86,7 @@ def pubchem_cid_description(cid):
     Returns:
         The description of the PubChem CID.
     """
-    logger.log(logging.INFO, "Load Hydra configuration for PubChem CID description.")
+    # 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'])

{aiagents4pharma-1.39.4.dist-info → aiagents4pharma-1.40.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aiagents4pharma
-Version: 1.39.4
+Version: 1.40.0
 Summary: AI Agents for drug discovery, drug development, and other pharmaceutical R&D.
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
@@ -63,6 +63,7 @@ Requires-Dist: plotly-express==0.4.1
 Requires-Dist: seaborn==0.13.2
 Requires-Dist: scanpy==1.11.0
 Requires-Dist: openpyxl==3.1.5
+Requires-Dist: pymilvus==2.5.11
 Dynamic: license-file
 
 [![Talk2BioModels](https://github.com/VirtualPatientEngine/AIAgents4Pharma/actions/workflows/tests_talk2biomodels.yml/badge.svg)](https://github.com/VirtualPatientEngine/AIAgents4Pharma/actions/workflows/tests_talk2biomodels.yml)
@@ -112,7 +113,9 @@ _We now have all the agents available on Docker Hub._
 
 ##### **To run Talk2AIAgents4Pharma / Talk2KnowledgeGraphs**
 
-Both agents require [Ollama](https://ollama.com/) to run embedding models like `nomic-embed-text`. We use a **single startup script** that automatically detects your hardware (NVIDIA, AMD, or CPU) and handles container startup, model loading, and service orchestration.
+If your machine has NVIDIA GPU(s), please install the following this:
+- [nvidia-cuda-toolkit](https://developer.nvidia.com/cuda-toolkit)
+- [nvidia-container-toolkit](https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/1.17.8/install-guide.html) (required for GPU support with Docker; enables containers to access NVIDIA GPUs for accelerated computing). After installing `nvidia-container-toolkit`, please restart Docker to ensure GPU support is enabled.
 
 ##### **1. Download docker-compose.yml, .env.example and startup.sh from GitHub**
 
@@ -141,7 +144,6 @@ Then edit `.env` and add your API keys:
 ```env
 OPENAI_API_KEY=...                  # Required for both agents
 NVIDIA_API_KEY=...                  # Required for both agents
-OLLAMA_HOST=http://ollama:11434     # Required for AA4P / T2KG
 LANGCHAIN_TRACING_V2=true           # Optional for both agents
 LANGCHAIN_API_KEY=...               # Optional for both agents
 ```
@@ -203,6 +205,10 @@ If you are using docker on Windows, please follow these [Windows Setup Notes](ht
 
 [More on running multiple agents simultaneously](https://github.com/VirtualPatientEngine/AIAgents4Pharma/blob/main/aiagents4pharma/talk2aiagents4pharma/install.md#to-run-multiple-agents-simultaneously)
 
+📝 By default, `talk2knowledgegraphs` includes a small subset of the PrimeKG knowledge graph, allowing users to start interacting with it out of the box.  
+To switch to a different knowledge graph or use your own, refer to the [deployment guide](https://virtualpatientengine.github.io/AIAgents4Pharma/talk2knowledgegraphs/deployment/).
+
+
 #### Option 2: git (for developers and contributors)
 
 ![Python Version from PEP 621 TOML](https://img.shields.io/python/required-version-toml?tomlFilePath=https%3A%2F%2Fraw.githubusercontent.com%2FVirtualPatientEngine%2FAIAgents4Pharma%2Frefs%2Fheads%2Fmain%2Fpyproject.toml)
@@ -238,16 +244,6 @@ Only for **Talk2Scholars**, you also need a **Zotero API key**, which you can ge
 
 To use **Talk2Scholars**, you must have **FAISS** installed through **Conda**. Follow installation instructions for your OS [here](https://github.com/VirtualPatientEngine/AIAgents4Pharma/tree/main/aiagents4pharma/talk2scholars/install.md).
 
-To use **Talk2AIAgents4Pharma** or **Talk2KnowledgeGraphs**, you must have **Ollama** installed. Follow installation instructions for your OS [here](https://ollama.com/download).
-
-After installing, pull the `nomic-embed-text` model and start the server by running:
-
-```sh
-ollama pull nomic-embed-text && ollama serve
-```
-
-More details about the model are available [here](https://ollama.com/library/nomic-embed-text).
-
 Additionally on **Windows**, the `pcst_fast 1.0.10` library requires **Microsoft Visual C++ 14.0 or greater**.  
 You can download the **Microsoft C++ Build Tools** [here](https://visualstudio.microsoft.com/visual-cpp-build-tools/).
 
@@ -273,6 +269,9 @@ _Replace `<agent>` with the agent name you are interested to launch:_
 - `talk2scholars`
 - `talk2cells`
 
+📝 By default, `talk2knowledgegraphs` includes a small subset of the PrimeKG knowledge graph, allowing users to start interacting with it out of the box.  
+To switch to a different knowledge graph or use your own, refer to the [deployment guide](https://virtualpatientengine.github.io/AIAgents4Pharma/talk2knowledgegraphs/deployment/).
+
 For detailed instructions on each agent, please refer to their respective modules.
 
 #### Option 3: pip (beta-release)
@@ -322,7 +321,7 @@ git push origin feat/your-feature-name
 #### Contacts for contributions
 
 - **Talk2Biomodels**: [@lilijap](https://github.com/lilijap), [@gurdeep330](https://github.com/gurdeep330)
-- **Talk2Cells**: [@gurdeep330](https://github.com/gurdeep330)
+- **Talk2Cells**: [@tAndreaniSanofi](https://github.com/tAndreaniSanofi), [@gurdeep330](https://github.com/gurdeep330)
 - **Talk2KnowledgeGraphs**: [@awmulyadi](https://github.com/awmulyadi)
 - **Talk2Scholars**: [@ansh-info](https://github.com/ansh-info), [@gurdeep330](https://github.com/gurdeep330)
 

{aiagents4pharma-1.39.4.dist-info → aiagents4pharma-1.40.0.dist-info}/RECORD

@@ -5,11 +5,11 @@ aiagents4pharma/talk2aiagents4pharma/agents/main_agent.py,sha256=gnXBvvi3t8DjUtX
 aiagents4pharma/talk2aiagents4pharma/configs/__init__.py,sha256=5ah__-8XyRblwT0U1ByRigNjt_GyCheu7zce4aM-eZE,68
 aiagents4pharma/talk2aiagents4pharma/configs/config.yaml,sha256=VnbMbVSYfCh68cHZ0JLu00UjOUmapejN3EsN3lnBXtU,51
 aiagents4pharma/talk2aiagents4pharma/configs/agents/__init__.py,sha256=zrJcq-4m0YUKfSlRGC8KzBmEooaASKuL_Y75yDp-ZoA,72
-aiagents4pharma/talk2aiagents4pharma/configs/agents/main_agent/default.yaml,sha256=GY8RiNatrkOkLClgkiAGDjL3bYspXaMbnh6n_e4JeJc,671
+aiagents4pharma/talk2aiagents4pharma/configs/agents/main_agent/default.yaml,sha256=Qkq-p_TV67n5BsXyAj88rA239HC0ogLYDqbDrIuGprc,2426
 aiagents4pharma/talk2aiagents4pharma/states/__init__.py,sha256=3wSvCpM29oqvVjhbhabm7FNm9Zt0rHO5tEn63YW6doc,108
 aiagents4pharma/talk2aiagents4pharma/states/state_talk2aiagents4pharma.py,sha256=NxujEBDKubvpV9UG7ERTDRB6psr0XnObCNHyztLAhgo,485
 aiagents4pharma/talk2aiagents4pharma/tests/__init__.py,sha256=Jbw5tJxSrjGoaK5IX3pJWDCNzhrVQ10lkYq2oQ_KQD8,45
-aiagents4pharma/talk2aiagents4pharma/tests/test_main_agent.py,sha256=_zUm8i8vrBbcDgpwExa1sVGr1A9FgZFuwoLS395RnhU,4418
+aiagents4pharma/talk2aiagents4pharma/tests/test_main_agent.py,sha256=V2GdYqbXhPa5vCC5-LD8HUw8S8DAaVC4X2kFa1MeF8o,7428
 aiagents4pharma/talk2biomodels/__init__.py,sha256=1cq1HX2xoi_a0nDPuXYoSTrnL26OHQBW3zXNwwwjFO0,181
 aiagents4pharma/talk2biomodels/agents/__init__.py,sha256=sn5-fREjMdEvb-OUan3iOqrgYGjplNx3J8hYOaW0Po8,128
 aiagents4pharma/talk2biomodels/agents/t2b_agent.py,sha256=g0DIW5P-dtJoVyG4weFdDgTrJPL_Dx1MMbTWextJDZ4,3455
@@ -72,15 +72,16 @@ aiagents4pharma/talk2cells/tools/scp_agent/__init__.py,sha256=s7g0lyH1lMD9pcWHLP
 aiagents4pharma/talk2cells/tools/scp_agent/display_studies.py,sha256=6q59gh_NQaiOU2rn55A3sIIFKlXi4SK3iKgySvUDrtQ,600
 aiagents4pharma/talk2cells/tools/scp_agent/search_studies.py,sha256=MLe-twtFnOu-P8P9diYq7jvHBHbWFRRCZLcfpUzqPMg,2806
 aiagents4pharma/talk2knowledgegraphs/__init__.py,sha256=Z0Eo7LTiKk0STsr8VI7wkCLq7PHrK1vYlH4I1hSNLiA,165
+aiagents4pharma/talk2knowledgegraphs/milvus_data_dump.py,sha256=YOTO1HcSpNxQdc83jgwcuFkzGeCHov7CRDHQQL9PHNE,22608
 aiagents4pharma/talk2knowledgegraphs/agents/__init__.py,sha256=iOAzuy_8A03tQDFtSBhC9dldUo62z5gfxcVtXAdLOJs,92
-aiagents4pharma/talk2knowledgegraphs/agents/t2kg_agent.py,sha256=w4wSSQ9gw_fzpcHZ2Bnqok17YDkFeQ3d72JenvQm6Oc,3089
+aiagents4pharma/talk2knowledgegraphs/agents/t2kg_agent.py,sha256=eUARAhzOz8PpHFzN2fP4L_fDEyqdllrAkBWa0otxGv4,3363
 aiagents4pharma/talk2knowledgegraphs/configs/__init__.py,sha256=4_DVdpahaJ55yPl0aZotlFA_MYWLFF2cubWyKtBVI_Q,126
 aiagents4pharma/talk2knowledgegraphs/configs/config.yaml,sha256=-AJXKnR2z5ig0SK_3vLL9JFjNRri7q7blHYFWxoTDl0,417
 aiagents4pharma/talk2knowledgegraphs/configs/agents/t2kg_agent/__init__.py,sha256=-fAORvyFmG2iSvFOFDixmt9OTQRR58y89uhhu2EgbA8,46
 aiagents4pharma/talk2knowledgegraphs/configs/agents/t2kg_agent/default.yaml,sha256=ENCGROwYFpR6g4QD518h73sshdn3vPVpotBMk1QJcpU,4830
 aiagents4pharma/talk2knowledgegraphs/configs/app/__init__.py,sha256=fKfc3FR7g5KjY9b6jzrU6cwKTVVpkoVZQS3dvUowu34,69
 aiagents4pharma/talk2knowledgegraphs/configs/app/frontend/__init__.py,sha256=-fAORvyFmG2iSvFOFDixmt9OTQRR58y89uhhu2EgbA8,46
-aiagents4pharma/talk2knowledgegraphs/configs/app/frontend/default.yaml,sha256=WJgd2ZU7_WQ1qlcTfkFlM8u23sH6eU2KgAm0E4kqqfs,941
+aiagents4pharma/talk2knowledgegraphs/configs/app/frontend/default.yaml,sha256=6qE7j4k3gO83TNA31XVDJus0gTJloO2sG5R_ovZw7VM,2269
 aiagents4pharma/talk2knowledgegraphs/configs/tools/__init__.py,sha256=C1yyRZW8hqWw46p_bh1vAJp2z9aVvn4HpKjKkjlWIqY,150
 aiagents4pharma/talk2knowledgegraphs/configs/tools/graphrag_reasoning/__init__.py,sha256=-fAORvyFmG2iSvFOFDixmt9OTQRR58y89uhhu2EgbA8,46
 aiagents4pharma/talk2knowledgegraphs/configs/tools/graphrag_reasoning/default.yaml,sha256=Ua99yECXiwp4ZCUDgsDskYbKzcJrv7roQuLj31Zky4c,1037
@@ -97,12 +98,13 @@ aiagents4pharma/talk2knowledgegraphs/datasets/starkqa_primekg.py,sha256=Y-6-nORs
 aiagents4pharma/talk2knowledgegraphs/states/__init__.py,sha256=XaqorSvx634dWRRlXUdzlisHtYMyqgJ2q7TanzsKlhw,108
 aiagents4pharma/talk2knowledgegraphs/states/state_talk2knowledgegraphs.py,sha256=y5bp6yObN-AQtTq-m8ml7UnZaeKYUiPV_yjskAzBJaI,1087
 aiagents4pharma/talk2knowledgegraphs/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-aiagents4pharma/talk2knowledgegraphs/tests/test_agents_t2kg_agent.py,sha256=PPfHKnfqMbUOBKU7q4VbQvHQymX1M_zTYdysQgVxKCs,3851
+aiagents4pharma/talk2knowledgegraphs/tests/test_agents_t2kg_agent.py,sha256=CmN2bS9Jv6P0m58JPgP9W2mreJThq2ZNY6PFP0Tltfs,6507
 aiagents4pharma/talk2knowledgegraphs/tests/test_datasets_biobridge_primekg.py,sha256=crH0eFA3P8P6IYzi1UWNa4YvRVrtlBzoScf9NaE1lDk,9827
 aiagents4pharma/talk2knowledgegraphs/tests/test_datasets_dataset.py,sha256=NFUlsZvhfIrkF4YenWfahrLK93Xhm5UYEGG_uYN2LVM,566
 aiagents4pharma/talk2knowledgegraphs/tests/test_datasets_primekg.py,sha256=Pvu0r93CpnhjkfMxc-EiVLpAJ04FdW9iTamCnetu654,2272
 aiagents4pharma/talk2knowledgegraphs/tests/test_datasets_starkqa_primekg.py,sha256=TuIsqcN1Mww3DTqGk6ebgJBWzUWdMWEq2yRQuYSFqvA,4416
 aiagents4pharma/talk2knowledgegraphs/tests/test_tools_graphrag_reasoning.py,sha256=aOKHTber2Cg3mjNjfIa6RZU7XdFj5C2ps1YEUXw76CI,10650
+aiagents4pharma/talk2knowledgegraphs/tests/test_tools_milvus_multimodal_subgraph_extraction.py,sha256=ATD3KDK-WQHG3t480u6sZavfMN7rTZcnhcCoQnPRocY,18889
 aiagents4pharma/talk2knowledgegraphs/tests/test_tools_multimodal_subgraph_extraction.py,sha256=Da-hXcu41_5Ge4DPlOoY6OqBwYnXPc58Q89wuywqVJM,5806
 aiagents4pharma/talk2knowledgegraphs/tests/test_tools_subgraph_extraction.py,sha256=C2HzmAG1XCeV1hwZzz3-9_2dm_84-i1BvTNWA1pqUwM,5393
 aiagents4pharma/talk2knowledgegraphs/tests/test_tools_subgraph_summarization.py,sha256=oBqfspXXOxH04OQuPb8BCW0liIQTGKXtaPNSrPpQtFc,7597
@@ -113,21 +115,23 @@ aiagents4pharma/talk2knowledgegraphs/tests/test_utils_embeddings_ollama.py,sha25
 aiagents4pharma/talk2knowledgegraphs/tests/test_utils_embeddings_sentencetransformer.py,sha256=Xkuf2UFGCXldj1zcsh6kqfQYLDf5i0B6KP3KcmNLSzQ,1452
 aiagents4pharma/talk2knowledgegraphs/tests/test_utils_enrichments_enrichments.py,sha256=N6HRr4lWHXY7bTHe2uXJe4D_EG9WqZPibZne6qLl9_k,1447
 aiagents4pharma/talk2knowledgegraphs/tests/test_utils_enrichments_ollama.py,sha256=JhY7axvVULLywDJ2ctA-gob5YPeaJYWsaMNjHT6L9CU,3021
-aiagents4pharma/talk2knowledgegraphs/tests/test_utils_enrichments_ols.py,sha256=5GTSkfKSDS5geR0YfilfnDyUsYli0hv7N8PiDwRvlIE,2370
+aiagents4pharma/talk2knowledgegraphs/tests/test_utils_enrichments_ols.py,sha256=5nSBLwfBnwq4K78Q4GM0zTeym5csxHhOwGwx2utBBEU,2280
 aiagents4pharma/talk2knowledgegraphs/tests/test_utils_enrichments_pubchem.py,sha256=0SgYvqdvxseUYTHx2KuSNI2hnmQ3VVVz0F-79_-P41o,1769
 aiagents4pharma/talk2knowledgegraphs/tests/test_utils_enrichments_reactome.py,sha256=r1D74mavsnSCm4xnWl0n0nM9PZqgm3doD2dulNrKNVQ,1754
 aiagents4pharma/talk2knowledgegraphs/tests/test_utils_enrichments_uniprot.py,sha256=G13Diw7cA5TGINUNO1CDnN4rM6KbepxRXNjuzY578DI,1611
+aiagents4pharma/talk2knowledgegraphs/tests/test_utils_extractions_milvus_multimodal_pcst.py,sha256=XlB39lhaCax1r5eAYdvaJqyWvxgG1MO8jKD4MWyuT68,7491
 aiagents4pharma/talk2knowledgegraphs/tests/test_utils_kg_utils.py,sha256=pal76wi7WgQWUNk56BrzfFV8jKpbDaHHdbwtgx_gXLI,2410
-aiagents4pharma/talk2knowledgegraphs/tests/test_utils_pubchem_utils.py,sha256=K1Y6QM0MDP1IrAdcWkigl8R-O-i-lsL4NCyOrWewhdM,1246
-aiagents4pharma/talk2knowledgegraphs/tools/__init__.py,sha256=uleTEbhgvlYw4fOqV4NmoFvxGTon2Oim7jTQ5qPmYoU,216
+aiagents4pharma/talk2knowledgegraphs/tests/test_utils_pubchem_utils.py,sha256=31WPX8MrhnztoHUROAlH5KvHeXMbB_Jndp3ypAKJO9E,1543
+aiagents4pharma/talk2knowledgegraphs/tools/__init__.py,sha256=u50fnnIhm7NHt4JhQeXdF_XtNYR2i35p4VRNQzP1CVQ,268
 aiagents4pharma/talk2knowledgegraphs/tools/graphrag_reasoning.py,sha256=OEuOFncDRdb7TQEGq4rkT5On-jI-R7Nt8K5EBzaND8w,5338
 aiagents4pharma/talk2knowledgegraphs/tools/load_arguments.py,sha256=zhmsRp-8vjB5rRekqTA07d3yb-42HWqng9dDMkvK6hM,623
+aiagents4pharma/talk2knowledgegraphs/tools/milvus_multimodal_subgraph_extraction.py,sha256=eANDj6b6l9Oc5fOZxGx-PInd9YfD4_4sDFFPuzPkFNs,21945
 aiagents4pharma/talk2knowledgegraphs/tools/multimodal_subgraph_extraction.py,sha256=Qjl8hXG8Gv5jQ4pBX8me0pGGakqRZmcDfTGgdEHD9pc,15394
 aiagents4pharma/talk2knowledgegraphs/tools/subgraph_extraction.py,sha256=te06QMFQfgJWrjaGrqpcOYeaV38jwm0KY_rXVSMHkeI,11468
 aiagents4pharma/talk2knowledgegraphs/tools/subgraph_summarization.py,sha256=mDSBOxopDfNhEJeU8fVI8b5lXTYrRzcc97aLbFgYSy4,4413
 aiagents4pharma/talk2knowledgegraphs/utils/__init__.py,sha256=cZqb3LZLmBnmyAtWFv2Z-4uJvQmx0M4zKsfiWrlM3Pk,195
 aiagents4pharma/talk2knowledgegraphs/utils/kg_utils.py,sha256=6vQnPkeOWae_8jePjhma3sJuMTngy0I0tqzdFt6OqKg,2507
-aiagents4pharma/talk2knowledgegraphs/utils/pubchem_utils.py,sha256=8cve_KLtQUhG3uMKYpyelZvpETSsNGRdGE4X0NXMk4M,2442
+aiagents4pharma/talk2knowledgegraphs/utils/pubchem_utils.py,sha256=kMSabEZDIa6BruoFtnvWQnUWX47FUmTo22CLihYz8F8,3458
 aiagents4pharma/talk2knowledgegraphs/utils/embeddings/__init__.py,sha256=POSDrSdFAWsBCueOPD-Fok-ARdTywJU1ivwpT9EU1Kw,199
 aiagents4pharma/talk2knowledgegraphs/utils/embeddings/embeddings.py,sha256=1nGznrAj-xT0xuSMBGz2dOujJ7M_IwSR84njxtxsy9A,2523
 aiagents4pharma/talk2knowledgegraphs/utils/embeddings/huggingface.py,sha256=2vi_elf6EgzfagFAO5QnL3a_aXZyN7B1EBziu44MTfM,3806
@@ -137,11 +141,12 @@ aiagents4pharma/talk2knowledgegraphs/utils/embeddings/sentence_transformer.py,sh
 aiagents4pharma/talk2knowledgegraphs/utils/enrichments/__init__.py,sha256=K157MWJ4dn2fj3G5ClhyAOXg9jI2H02GP07J6UpasJw,230
 aiagents4pharma/talk2knowledgegraphs/utils/enrichments/enrichments.py,sha256=Bx8x6zzk5614ApWB90N_iv4_Y_Uq0-KwUeBwYSdQMU4,924
 aiagents4pharma/talk2knowledgegraphs/utils/enrichments/ollama.py,sha256=8eoxR-VHo0G7ReQIwje7xEhE-SJlHdef7_wJRpnvFIc,4116
-aiagents4pharma/talk2knowledgegraphs/utils/enrichments/ols_terms.py,sha256=xSPP-h2q9fABz6Sd6ZlH9WiyoO8KZeEnPI5n2nJpWL4,2443
-aiagents4pharma/talk2knowledgegraphs/utils/enrichments/pubchem_strings.py,sha256=CQEGQ6Qsex2T91Vw7zTrclJBbSGGhxeWaVJb8tnURAQ,1691
+aiagents4pharma/talk2knowledgegraphs/utils/enrichments/ols_terms.py,sha256=QLINhZM51A8JwFoF0INzdUFT2pdlc_h0rdYRgKr49vQ,2772
+aiagents4pharma/talk2knowledgegraphs/utils/enrichments/pubchem_strings.py,sha256=zdBYhRxYfdNSViBwDNwc-9DTYkYGTPlyyHB_OIgbb3E,2630
 aiagents4pharma/talk2knowledgegraphs/utils/enrichments/reactome_pathways.py,sha256=I0cD0Fk2Uk27_4jEaIhpoGhoMh_RphY1VtkMnk4dkPg,2011
 aiagents4pharma/talk2knowledgegraphs/utils/enrichments/uniprot_proteins.py,sha256=z0Jb3tt8VzRjzqI9oVcUvRlPPg6BUdmslfKDIEFE_h8,3013
-aiagents4pharma/talk2knowledgegraphs/utils/extractions/__init__.py,sha256=5bt3H6gGSAwN2K-IG7AHwG2lC4yQeMd2_jbhu2z5XKg,116
+aiagents4pharma/talk2knowledgegraphs/utils/extractions/__init__.py,sha256=6xVclMlSuAIHQXBvn5D9zRLDzSv2LWLcAwDQw-nwZgM,153
+aiagents4pharma/talk2knowledgegraphs/utils/extractions/milvus_multimodal_pcst.py,sha256=peFGn9XXpE7H9leVqQHc2Ec7x2ZRiehYkcCCCNo3b_E,16415
 aiagents4pharma/talk2knowledgegraphs/utils/extractions/multimodal_pcst.py,sha256=Irh5JXEhaLZ6Rxv3h5Anif_rGNItyLOGDWg1RACmoDA,12628
 aiagents4pharma/talk2knowledgegraphs/utils/extractions/pcst.py,sha256=m5p0yoJb7I19ua5yeQfXPf7c4r6S1XPwttsrM7Qoy94,9336
 aiagents4pharma/talk2scholars/__init__.py,sha256=NOZxTklAH1j1ggu97Ib8Xn9LCKudEWt-8dx8w7yxVD8,180
@@ -251,8 +256,8 @@ aiagents4pharma/talk2scholars/tools/zotero/utils/review_helper.py,sha256=IPD1V9y
 aiagents4pharma/talk2scholars/tools/zotero/utils/write_helper.py,sha256=ALwLecy1QVebbsmXJiDj1GhGmyhq2R2tZlAyEl1vfhw,7410
 aiagents4pharma/talk2scholars/tools/zotero/utils/zotero_path.py,sha256=oIrfbOySgts50ksHKyjcWjRkPRIS88g3Lc0v9mBkU8w,6375
 aiagents4pharma/talk2scholars/tools/zotero/utils/zotero_pdf_downloader.py,sha256=ERBha8afU6Q1EaRBe9qB8tchOzZ4_KfFgDW6EElOJoU,4816
-aiagents4pharma-1.39.4.dist-info/licenses/LICENSE,sha256=IcIbyB1Hyk5ZDah03VNQvJkbNk2hkBCDqQ8qtnCvB4Q,1077
-aiagents4pharma-1.39.4.dist-info/METADATA,sha256=0vzjxCMHm4xhDVEZoMhq68SJBox2dvrEV8GEJNcLvLY,15462
-aiagents4pharma-1.39.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-aiagents4pharma-1.39.4.dist-info/top_level.txt,sha256=-AH8rMmrSnJtq7HaAObS78UU-cTCwvX660dSxeM7a0A,16
-aiagents4pharma-1.39.4.dist-info/RECORD,,
+aiagents4pharma-1.40.0.dist-info/licenses/LICENSE,sha256=IcIbyB1Hyk5ZDah03VNQvJkbNk2hkBCDqQ8qtnCvB4Q,1077
+aiagents4pharma-1.40.0.dist-info/METADATA,sha256=jd8SL6NNmmj29FeubrC3KIZAQ3vWKuQjdPCQDCs5Wio,15945
+aiagents4pharma-1.40.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+aiagents4pharma-1.40.0.dist-info/top_level.txt,sha256=-AH8rMmrSnJtq7HaAObS78UU-cTCwvX660dSxeM7a0A,16
+aiagents4pharma-1.40.0.dist-info/RECORD,,