aiagents4pharma 1.6.2__py3-none-any.whl → 1.7.0__py3-none-any.whl

aiagents4pharma/talk2biomodels/models/basico_model.py

@@ -5,20 +5,23 @@ BasicoModel class for loading and simulating SBML models
 using the basico package.
 """
 
+import logging
 from typing import Optional, Dict, Union
-from time import sleep
-from urllib.error import URLError
 from pydantic import Field, model_validator
 import pandas as pd
 import basico
 from .sys_bio_model import SysBioModel
 
+# Initialize logger
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
 class BasicoModel(SysBioModel):
     """
     Model that loads and simulates SBML models using the basico package.
-    Can load models from an SBML file or download them using a BioModels model_id.
+    Can load models from an SBML file or download them using a BioModels biomodel_id.
     """
-    model_id: Optional[int] = Field(None, description="BioModels model ID to download and load")
+    biomodel_id: Optional[int] = Field(None, description="BioModels model ID to download and load")
     sbml_file_path: Optional[str] = Field(None, description="Path to an SBML file to load")
     simulation_results: Optional[str] = None
     name: Optional[str] = Field("", description="Name of the model")
@@ -28,27 +31,21 @@ class BasicoModel(SysBioModel):
     copasi_model: Optional[object] = None  # Holds the loaded Copasi model
 
     @model_validator(mode="after")
-    def check_model_id_or_sbml_file_path(self):
+    def check_biomodel_id_or_sbml_file_path(self):
         """
-        Validate that either model_id or sbml_file_path is provided.
+        Validate that either biomodel_id or sbml_file_path is provided.
         """
-        if not self.model_id and not self.sbml_file_path:
-            raise ValueError("Either model_id or sbml_file_path must be provided.")
-        if self.model_id:
-            attempts = 0
-            max_retries = 5
-            while attempts < max_retries:
-                try:
-                    self.copasi_model = basico.load_biomodel(self.model_id)
-                    break
-                except URLError as e:
-                    attempts += 1
-                    sleep(10*attempts)
-                    if attempts >= max_retries:
-                        raise e
-            self.description = basico.biomodels.get_model_info(self.model_id)["description"]
+        if not self.biomodel_id and not self.sbml_file_path:
+            logger.error("Either biomodel_id or sbml_file_path must be provided.")
+            raise ValueError("Either biomodel_id or sbml_file_path must be provided.")
+        if self.biomodel_id:
+            self.copasi_model = basico.load_biomodel(self.biomodel_id)
+            self.description = basico.biomodels.get_model_info(self.biomodel_id)["description"]
+            self.name = basico.model_info.get_model_name(model=self.copasi_model)
         elif self.sbml_file_path:
             self.copasi_model = basico.load_model(self.sbml_file_path)
+            self.description = basico.model_info.get_notes(model=self.copasi_model)
+            self.name = basico.model_info.get_model_name(model=self.copasi_model)
         return self
 
     def simulate(self,
@@ -92,10 +89,16 @@ class BasicoModel(SysBioModel):
         df_result = basico.run_time_course(model=self.copasi_model,
                                         intervals=interval,
                                         duration=duration)
+        # Replace curly braces in column headers with square brackets
+        # Because curly braces in the world of LLMS are used for
+        # structured output
         df_result.columns = df_result.columns.str.replace('{', '[', regex=False).\
                     str.replace('}', ']', regex=False)
+        # Reset the index
         df_result.reset_index(inplace=True)
+        # Store the simulation results
         self.simulation_results = df_result
+        # Return copy of the simulation results
         return df_result.copy()
 
     def get_model_metadata(self) -> Dict[str, Union[str, int]]:

aiagents4pharma/talk2biomodels/models/sys_bio_model.py

@@ -12,18 +12,18 @@ class SysBioModel(ABC, BaseModel):
     This class serves as a general structure for models, allowing
     different mathematical approaches to be implemented in subclasses.
     """
-    model_id: Optional[int] = Field(None, description="BioModel ID of the model")
+    biomodel_id: Optional[int] = Field(None, description="BioModel ID of the model")
     sbml_file_path: Optional[str] = Field(None, description="Path to an SBML file")
     name: Optional[str] = Field(..., description="Name of the model")
     description: Optional[str] = Field("", description="Description of the model")
 
     @model_validator(mode="after")
-    def check_model_id_or_sbml_file_path(self):
+    def check_biomodel_id_or_sbml_file_path(self):
         """
-        Validate that either model_id or sbml_file_path is provided.
+        Validate that either biomodel_id or sbml_file_path is provided.
         """
-        if not self.model_id and not self.sbml_file_path:
-            raise ValueError("Either model_id or sbml_file_path must be provided.")
+        if not self.biomodel_id and not self.sbml_file_path:
+            raise ValueError("Either biomodel_id or sbml_file_path must be provided.")
         return self
 
     @abstractmethod

aiagents4pharma/talk2biomodels/tools/__init__.py

@@ -1,10 +1,8 @@
 '''
 This file is used to import all the modules in the package.
 '''
-# import everything from the module
-from . import ask_question
+from . import search_models
 from . import simulate_model
+from . import ask_question
 from . import custom_plotter
-from . import fetch_parameters
-from . import model_description
-from . import search_models
+from . import get_modelinfo

aiagents4pharma/talk2biomodels/tools/ask_question.py

@@ -4,34 +4,30 @@
 Tool for asking a question about the simulation results.
 """
 
-from typing import Type, Optional
-from dataclasses import dataclass
-import streamlit as st
+import logging
+from typing import Type, Annotated
+import pandas as pd
 from pydantic import BaseModel, Field
 from langchain_core.tools.base import BaseTool
-from langchain_core.callbacks import CallbackManagerForToolRun
 from langchain.agents.agent_types import AgentType
 from langchain_experimental.agents import create_pandas_dataframe_agent
 from langchain_openai import ChatOpenAI
-from ..models.basico_model import BasicoModel
+from langgraph.prebuilt import InjectedState
 
-@dataclass
-class ModelData:
-    """
-    Dataclass for storing the model data.
-    """
-    modelid: Optional[int] = None
-    sbml_file_path: Optional[str] = None
-    model_object: Optional[BasicoModel] = None
+# Initialize logger
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
 
 class AskQuestionInput(BaseModel):
     """
     Input schema for the AskQuestion tool.
     """
     question: str = Field(description="question about the simulation results")
+    state: Annotated[dict, InjectedState]
 
-# Note: It's important that every field has type hints. BaseTool is a
-# Pydantic class and not having type hints can lead to unexpected behavior.
+# Note: It's important that every field has type hints.
+# BaseTool is a Pydantic class and not having type hints
+# can lead to unexpected behavior.
 class AskQuestionTool(BaseTool):
     """
     Tool for calculating the product of two numbers.
@@ -39,75 +35,38 @@ class AskQuestionTool(BaseTool):
     name: str = "ask_question"
     description: str = "A tool to ask question about the simulation results."
     args_schema: Type[BaseModel] = AskQuestionInput
-    return_direct: bool = True
-    st_session_key: str = None
-    sys_bio_model: ModelData = ModelData()
+    return_direct: bool = False
 
     def _run(self,
              question: str,
-             run_manager: Optional[CallbackManagerForToolRun] = None) -> str:
+             state: Annotated[dict, InjectedState]) -> str:
         """
         Run the tool.
 
         Args:
             question (str): The question to ask about the simulation results.
+            state (dict): The state of the graph.
             run_manager (Optional[CallbackManagerForToolRun]): The CallbackManagerForToolRun object.
 
         Returns:
             str: The answer to the question.
         """
-        st_session_key = self.st_session_key
-        sys_bio_model = self.sys_bio_model
-        # Check if sys_bio_model is provided in the input
-        if sys_bio_model.modelid or sys_bio_model.sbml_file_path or sys_bio_model.model_object:
-            if sys_bio_model.modelid is not None:
-                model_object = BasicoModel(model_id=sys_bio_model.modelid)
-            elif sys_bio_model.sbml_file_path is not None:
-                model_object = BasicoModel(sbml_file_path=sys_bio_model.sbml_file_path)
-            else:
-                model_object = sys_bio_model.model_object
-        else:
-            # If the sys_bio_model is not provided in the input,
-            # get it from the Streamlit session state
-            if st_session_key:
-                if st_session_key not in st.session_state:
-                    return f"Session key {st_session_key} not found in Streamlit session state."
-                model_object = st.session_state[st_session_key]
-            else:
-                return "Please provide a valid model object or \
-                    Streamlit session key that contains the model object."
-        # Update the object in the streamlit session state
-        if st_session_key:
-            st.session_state[st_session_key] = model_object
-        if model_object.simulation_results is None:
-            model_object.simulate()
-        df = model_object.simulation_results
-        # If there is a Streamlit session key,
-        # display the simulation results
-        if st_session_key:
-            st.text(f"Simulation Results of the model {model_object.model_id}")
-            st.dataframe(df, use_container_width = False, width = 650)
-        # Check if run_manager's metadata has the key 'prompt_content'
+        logger.log(logging.INFO,
+                   "Calling ask_question tool %s", question)
+        # Check if the simulation results are available
+        if 'dic_simulated_data' not in state:
+            return "Please run the simulation first before \
+                asking a question about the simulation results."
+        df = pd.DataFrame.from_dict(state['dic_simulated_data'])
         prompt_content = None
-        if run_manager and 'prompt' in run_manager.metadata:
-            prompt_content = run_manager.metadata['prompt']
+        # if run_manager and 'prompt' in run_manager.metadata:
+        #     prompt_content = run_manager.metadata['prompt']
         # Create a pandas dataframe agent with OpenAI
-        df_agent = create_pandas_dataframe_agent(ChatOpenAI(model="gpt-3.5-turbo"),
-                                                  allow_dangerous_code=True,
-                                                  agent_type=AgentType.OPENAI_FUNCTIONS,
-                                                  df=df,
-                                                  prefix=prompt_content)
+        df_agent = create_pandas_dataframe_agent(
+                        ChatOpenAI(model=state['llm_model']),
+                        allow_dangerous_code=True,
+                        agent_type=AgentType.OPENAI_FUNCTIONS,
+                        df=df,
+                        prefix=prompt_content)
         llm_result = df_agent.invoke(question)
         return llm_result["output"]
-
-    def get_metadata(self):
-        """
-        Get metadata for the tool.
-
-        Returns:
-            dict: The metadata for the tool.
-        """
-        return {
-            "name": self.name,
-            "description": self.description
-        }

aiagents4pharma/talk2biomodels/tools/custom_plotter.py

@@ -5,75 +5,80 @@ Tool for plotting a custom figure.
 """
 
 import logging
-from typing import Type, List, TypedDict
+from typing import Type, List, TypedDict, Annotated, Tuple, Union, Literal
 from pydantic import BaseModel, Field
-import streamlit as st
+import pandas as pd
 from langchain_openai import ChatOpenAI
 from langchain_core.tools import BaseTool
-from langchain_core.prompts import ChatPromptTemplate
+from langgraph.prebuilt import InjectedState
 
 # Initialize logger
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-class CustomHeader(TypedDict):
-    """
-    A list of headers extracted from the user question.
-    """
-    y: List[str]
-
 class CustomPlotterInput(BaseModel):
     """
     Input schema for the PlotImage tool.
     """
     question: str = Field(description="Description of the plot")
+    state: Annotated[dict, InjectedState]
 
-# Note: It's important that every field has type hints. BaseTool is a
-# Pydantic class and not having type hints can lead to unexpected behavior.
+# Note: It's important that every field has type hints.
+# BaseTool is a Pydantic class and not having type hints
+# can lead to unexpected behavior.
 class CustomPlotterTool(BaseTool):
     """
     Tool for plotting a custom plot.
     """
     name: str = "custom_plotter"
-    description: str = "A tool to plot or visualize the simulation results."
+    description: str = "A tool to plot a custom figure."
     args_schema: Type[BaseModel] = CustomPlotterInput
-    st_session_key: str = None
+    response_format: str = "content_and_artifact"
 
-    def _run(self, question: str) -> str:
+    def _run(self,
+             question: str,
+             state: Annotated[dict, InjectedState]
+             ) -> Tuple[str, Union[None, List[str]]]:
         """
         Run the tool.
 
         Args:
-            question (str): The question to ask about the model description.
+            question (str): The question about the custom plot.
+            state (dict): The state of the graph.
 
         Returns:
             str: The answer to the question
         """
-        # Check if sys_bio_model is provided
-        model_object = st.session_state[self.st_session_key]
-        if model_object is None:
-            return "Please run the simulation first before plotting the figure."
-        if model_object.simulation_results is None:
-            return "Please run the simulation first before plotting the figure."
-        df = model_object.simulation_results
-        species_names = "\n".join(df.columns.tolist())
-        llm = ChatOpenAI(model="gpt-4o")
-        system = f"""
-        Given the user question: {question},
-        and the species: {species_names},
-        which species are relevant to the user's question?
-        """
+        logger.log(logging.INFO, "Calling custom_plotter tool %s", question)
+        # Check if the simulation results are available
+        # if 'dic_simulated_data' not in state:
+        #     return "Please run the simulation first before plotting the figure.", None
+        df = pd.DataFrame.from_dict(state['dic_simulated_data'])
+        species_names = df.columns.tolist()
+        # Exclude the time column
+        species_names.remove('Time')
+        # In the following code, we extract the species
+        # from the user question. We use Literal to restrict
+        # the species names to the ones available in the
+        # simulation results.
+        class CustomHeader(TypedDict):
+            """
+            A list of species based on user question.
+            """
+            relevant_species: Union[None, List[Literal[*species_names]]] = Field(
+                                        description="List of species based on user question.")
+        # Create an instance of the LLM model
+        llm = ChatOpenAI(model=state['llm_model'], temperature=0)
         llm_with_structured_output = llm.with_structured_output(CustomHeader)
-        system_prompt_structured_output = ChatPromptTemplate.from_template(system)
-        chain = system_prompt_structured_output | llm_with_structured_output
-        results = chain.invoke({"input": question})
-        logger.info("Suggestions: %s", results)
+        results = llm_with_structured_output.invoke(question)
         extracted_species = []
-        for species in results['y']:
-            if species in df.columns.tolist():
+        # Extract the species from the results
+        # that are available in the simulation results
+        for species in results['relevant_species']:
+            if species in species_names:
                 extracted_species.append(species)
         logger.info("Extracted species: %s", extracted_species)
-        st.session_state.custom_simulation_results = extracted_species
         if len(extracted_species) == 0:
-            return "No species found in the simulation results that matches the user prompt."
-        return "Plotted the figure using the following species: " + str(extracted_species)
+            return "No species found in the simulation results that matches the user prompt.", None
+        content = f"Plotted custom figure with species: {', '.join(extracted_species)}"
+        return content, extracted_species

aiagents4pharma/talk2biomodels/tools/get_modelinfo.py

@@ -0,0 +1,130 @@
+#!/usr/bin/env python3
+
+"""
+Tool for get model information.
+"""
+
+import logging
+from typing import Type, Optional, Annotated
+from dataclasses import dataclass
+import basico
+from pydantic import BaseModel, Field
+from langchain_core.tools import BaseTool
+from langchain_core.messages import ToolMessage
+from langchain_core.tools.base import InjectedToolCallId
+from langgraph.prebuilt import InjectedState
+from langgraph.types import Command
+from .load_biomodel import ModelData, load_biomodel
+
+# Initialize logger
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+@dataclass
+class RequestedModelInfo:
+    """
+    Dataclass for storing the requested model information.
+    """
+    species: bool = Field(description="Get species from the model.")
+    parameters: bool = Field(description="Get parameters from the model.")
+    compartments: bool = Field(description="Get compartments from the model.")
+    units: bool = Field(description="Get units from the model.")
+    description: bool = Field(description="Get description from the model.")
+    name: bool = Field(description="Get name from the model.")
+
+class GetModelInfoInput(BaseModel):
+    """
+    Input schema for the GetModelInfo tool.
+    """
+    requested_model_info: RequestedModelInfo = Field(description="requested model information")
+    sys_bio_model: ModelData = Field(description="model data")
+    tool_call_id: Annotated[str, InjectedToolCallId]
+    state: Annotated[dict, InjectedState]
+
+# Note: It's important that every field has type hints. BaseTool is a
+# Pydantic class and not having type hints can lead to unexpected behavior.
+class GetModelInfoTool(BaseTool):
+    """
+    This tool ise used extract model information.
+    """
+    name: str = "get_parameters"
+    description: str = "A tool for extracting model information."
+    args_schema: Type[BaseModel] = GetModelInfoInput
+
+    def _run(self,
+            requested_model_info: RequestedModelInfo,
+            tool_call_id: Annotated[str, InjectedToolCallId],
+            state: Annotated[dict, InjectedState],
+            sys_bio_model: Optional[ModelData] = None,
+             ) -> Command:
+        """
+        Run the tool.
+
+        Args:
+            requested_model_info (RequestedModelInfo): The requested model information.
+            tool_call_id (str): The tool call ID. This is injected by the system.
+            state (dict): The state of the tool.
+            sys_bio_model (ModelData): The model data.
+
+        Returns:
+            Command: The updated state of the tool.
+        """
+        logger.log(logging.INFO,
+                   "Calling get_modelinfo tool %s, %s",
+                     sys_bio_model,
+                   requested_model_info)
+        # print (state, 'state')
+        sbml_file_path = state['sbml_file_path'][-1] if len(state['sbml_file_path']) > 0 else None
+        model_obj = load_biomodel(sys_bio_model,
+                                  sbml_file_path=sbml_file_path)
+        dic_results = {}
+        # Extract species from the model
+        if requested_model_info.species:
+            df_species = basico.model_info.get_species(model=model_obj.copasi_model)
+            dic_results['Species'] = df_species.index.tolist()
+            dic_results['Species'] = ','.join(dic_results['Species'])
+
+        # Extract parameters from the model
+        if requested_model_info.parameters:
+            df_parameters = basico.model_info.get_parameters(model=model_obj.copasi_model)
+            dic_results['Parameters'] = df_parameters.index.tolist()
+            dic_results['Parameters'] = ','.join(dic_results['Parameters'])
+
+        # Extract compartments from the model
+        if requested_model_info.compartments:
+            df_compartments = basico.model_info.get_compartments(model=model_obj.copasi_model)
+            dic_results['Compartments'] = df_compartments.index.tolist()
+            dic_results['Compartments'] = ','.join(dic_results['Compartments'])
+
+        # Extract description from the model
+        if requested_model_info.description:
+            dic_results['Description'] = model_obj.description
+
+        # Extract description from the model
+        if requested_model_info.name:
+            dic_results['Name'] = model_obj.name
+
+        # Extract time unit from the model
+        if requested_model_info.units:
+            dic_results['Units'] = basico.model_info.get_model_units(model=model_obj.copasi_model)
+
+        # Prepare the dictionary of updated state for the model
+        dic_updated_state_for_model = {}
+        for key, value in {
+                        "model_id": [sys_bio_model.biomodel_id],
+                        "sbml_file_path": [sbml_file_path],
+                        }.items():
+            if value:
+                dic_updated_state_for_model[key] = value
+
+        return Command(
+            update=dic_updated_state_for_model|{
+                    # update the message history
+                    "messages": [
+                        ToolMessage(
+                            content=dic_results,
+                            tool_call_id=tool_call_id
+                            )
+                        ],
+                    }
+            )

aiagents4pharma/talk2biomodels/tools/load_biomodel.py

@@ -0,0 +1,29 @@
+#!/usr/bin/env python3
+
+"""
+Function for loading the BioModel.
+"""
+
+from dataclasses import dataclass
+from ..models.basico_model import BasicoModel
+
+@dataclass
+class ModelData:
+    """
+    Dataclass for storing the model data.
+    """
+    biomodel_id: int = None
+    # sbml_file_path: Optional[str] = None
+    use_uploaded_sbml_file: bool = False
+
+def load_biomodel(sys_bio_model, sbml_file_path=None):
+    """
+    Load the BioModel.
+    """
+    model_object = None
+    if sys_bio_model.biomodel_id:
+        model_object = BasicoModel(biomodel_id=sys_bio_model.biomodel_id)
+    elif sbml_file_path:
+        model_object = BasicoModel(sbml_file_path=sbml_file_path)
+    return model_object
+    # return None

aiagents4pharma/talk2biomodels/tools/search_models.py

@@ -4,21 +4,21 @@
 Tool for searching models based on search query.
 """
 
-from urllib.error import URLError
-from time import sleep
-from typing import Type
+from typing import Type, Annotated
 from pydantic import BaseModel, Field
 from basico import biomodels
 from langchain_core.tools import BaseTool
 from langchain_core.output_parsers import StrOutputParser
 from langchain_core.prompts import ChatPromptTemplate
 from langchain_openai import ChatOpenAI
+from langgraph.prebuilt import InjectedState
 
 class SearchModelsInput(BaseModel):
     """
     Input schema for the search models tool.
     """
     query: str = Field(description="Search models query", default=None)
+    state: Annotated[dict, InjectedState]
 
 # Note: It's important that every field has type hints. BaseTool is a
 # Pydantic class and not having type hints can lead to unexpected behavior.
@@ -31,7 +31,9 @@ class SearchModelsTool(BaseTool):
     args_schema: Type[BaseModel] = SearchModelsInput
     return_direct: bool = True
 
-    def _run(self, query: str) -> str:
+    def _run(self,
+             query: str,
+             state: Annotated[dict, InjectedState]) -> dict:
         """
         Run the tool.
 
@@ -39,20 +41,10 @@ class SearchModelsTool(BaseTool):
             query (str): The search query.
 
         Returns:
-            str: The answer to the question.
+            dict: The answer to the question in the form of a dictionary.
         """
-        attempts = 0
-        max_retries = 3
-        while attempts < max_retries:
-            try:
-                search_results = biomodels.search_for_model(query)
-                break
-            except URLError as e:
-                attempts += 1
-                sleep(10)
-                if attempts >= max_retries:
-                    raise e
-        llm = ChatOpenAI(model="gpt-4o-mini")
+        search_results = biomodels.search_for_model(query)
+        llm = ChatOpenAI(model=state['llm_model'])
         # Check if run_manager's metadata has the key 'prompt_content'
         prompt_content = f'''
                         Convert the input into a table.
@@ -80,15 +72,3 @@ class SearchModelsTool(BaseTool):
         parser = StrOutputParser()
         chain = prompt_template | llm | parser
         return chain.invoke({"input": search_results})
-
-    def get_metadata(self):
-        """
-        Get metadata for the tool.
-
-        Returns:
-            dict: The metadata for the tool.
-        """
-        return {
-            "name": self.name,
-            "description": self.description
-        }

aiagents4pharma/talk2biomodels/tools/simulate_model.py

@@ -4,22 +4,21 @@
 Tool for simulating a model.
 """
 
-from typing import Type, Union, List, Optional
+import logging
 from dataclasses import dataclass
+from typing import Type, Union, List, Annotated
 import basico
 from pydantic import BaseModel, Field
+from langgraph.types import Command
+from langgraph.prebuilt import InjectedState
 from langchain_core.tools import BaseTool
-import streamlit as st
-# import plotly.express as px
-from ..models.basico_model import BasicoModel
+from langchain_core.messages import ToolMessage
+from langchain_core.tools.base import InjectedToolCallId
+from .load_biomodel import ModelData, load_biomodel
 
-@dataclass
-class ModelData:
-    """
-    Dataclass for storing the model data.
-    """
-    modelid: Optional[int] = None
-    sbml_file_path: Optional[str] = None
+# Initialize logger
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
 
 @dataclass
 class TimeData:
@@ -34,17 +33,20 @@ class SpeciesData:
     """
     Dataclass for storing the species data.
     """
-    species_name: List[str] = None
-    species_concentration: List[Union[int, float]] = None
+    species_name: List[str] = Field(description="species name", default=None)
+    species_concentration: List[Union[int, float]] = Field(
+        description="initial species concentration",
+        default=None)
 
 @dataclass
 class TimeSpeciesNameConcentration:
     """
     Dataclass for storing the time, species name, and concentration data.
     """
-    time: Union[int, float] = None
-    species_name: str = None
-    species_concentration: Union[int, float] = None
+    time: Union[int, float] = Field(description="time point where the event occurs")
+    species_name: str = Field(description="species name")
+    species_concentration: Union[int, float] = Field(
+        description="species concentration at the time point")
 
 @dataclass
 class RecurringData:
@@ -52,16 +54,43 @@ class RecurringData:
     Dataclass for storing the species and time data 
     on recurring basis.
     """
-    data: List[TimeSpeciesNameConcentration] = None
+    data: List[TimeSpeciesNameConcentration] = Field(
+        description="species and time data on recurring basis",
+        default=None)
+
+@dataclass
+class ArgumentData:
+    """
+    Dataclass for storing the argument data.
+    """
+    time_data: TimeData = Field(description="time data", default=None)
+    species_data: SpeciesData = Field(
+        description="species name and initial concentration data",
+        default=None)
+    recurring_data: RecurringData = Field(
+        description="species and time data on recurring basis",
+        default=None)
+
+def add_rec_events(model_object, recurring_data):
+    """
+    Add recurring events to the model.
+    """
+    for row in recurring_data.data:
+        tp, sn, sc = row.time, row.species_name, row.species_concentration
+        basico.add_event(f'{sn}_{tp}',
+                            f'Time > {tp}',
+                            [[sn, str(sc)]],
+                            model=model_object.copasi_model)
 
 class SimulateModelInput(BaseModel):
     """
     Input schema for the SimulateModel tool.
     """
-    model_data: ModelData = Field(description="model data", default=None)
-    time_data: TimeData = Field(description="time data", default=None)
-    species_data: SpeciesData = Field(description="species data", default=None)
-    recurring_data: RecurringData = Field(description="recurring data", default=None)
+    sys_bio_model: ModelData = Field(description="model data", default=None)
+    arg_data: ArgumentData = Field(description="time, species, and recurring data",
+                                        default=None)
+    tool_call_id: Annotated[str, InjectedToolCallId]
+    state: Annotated[dict, InjectedState]
 
 # Note: It's important that every field has type hints. BaseTool is a
 # Pydantic class and not having type hints can lead to unexpected behavior.
@@ -72,119 +101,78 @@ class SimulateModelTool(BaseTool):
     name: str = "simulate_model"
     description: str = "A tool to simulate a model."
     args_schema: Type[BaseModel] = SimulateModelInput
-    st_session_key: str = None
 
     def _run(self,
-                model_data: ModelData = None,
-                time_data: TimeData = None,
-                species_data: SpeciesData = None,
-                recurring_data: RecurringData = None):
+        tool_call_id: Annotated[str, InjectedToolCallId],
+        state: Annotated[dict, InjectedState],
+        sys_bio_model: ModelData = None,
+        arg_data: ArgumentData = None
+    ) -> Command:
         """
         Run the tool.
 
         Args:
-            model_data (Optional[ModelData]): The model data.
-            time_data (Optional[TimeData]): The time data.
-            species_data (Optional[SpeciesData]): The species data.
-            recurring_data (Optional[RecurringData]): The recurring data.
+            tool_call_id (str): The tool call ID. This is injected by the system.
+            state (dict): The state of the tool.
+            sys_bio_model (ModelData): The model data.
+            arg_data (ArgumentData): The argument data.
 
         Returns:
             str: The result of the simulation.
         """
-        # st_session_key = self.st_session_key
-        # Retrieve the model ID, duration, and interval
-        modelid = model_data.modelid if model_data is not None else None
-        # duration = time_data.duration if time_data is not None else 100.0
-        # interval = time_data.interval if time_data is not None else 10
+        logger.log(logging.INFO,
+                   "Calling simulate_model tool %s, %s",
+                   sys_bio_model,
+                   arg_data)
+        sbml_file_path = state['sbml_file_path'][-1] if len(state['sbml_file_path']) > 0 else None
+        model_object = load_biomodel(sys_bio_model,
+                                  sbml_file_path=sbml_file_path)
         # Prepare the dictionary of species data
         # that will be passed to the simulate method
         # of the BasicoModel class
-        # dic_species_data = None
-        # if species_data is not None:
-        #     dic_species_data = dict(zip(species_data.species_name,
-        #                             species_data.species_concentration))
-        dic_species_data = dict(zip(species_data.species_name, \
-            species_data.species_concentration)) \
-                if species_data is not None else None
-        # Retrieve the SBML file path from the Streamlit session state
-        # otherwise retrieve it from the model_data object if the user
-        # has provided it.
-        sbml_file_path = model_data.sbml_file_path if model_data is not None else None
-        if self.st_session_key:
-            if self.st_session_key not in st.session_state:
-                return f"Session key {self.st_session_key} not found in Streamlit session state."
-            if 'sbml_file_path' in st.session_state:
-                sbml_file_path = st.session_state.sbml_file_path
-        # Check if both modelid and sbml_file_path are None
-        if modelid is None and sbml_file_path is None:
-            # Then load the model from the Streamlit session state
-            # if the streamlit session exists
-            if self.st_session_key:
-                model_object = st.session_state[self.st_session_key]
-                # If this model object is None, then return an error message
-                if model_object is None:
-                    return "Please provide a BioModels ID or an SBML file path for simulation."
-                # Retrieve the model ID from the model object
-                modelid = model_object.model_id
-            else:
-                # Otherwise return an error message
-                return "Please provide a BioModels ID or an SBML file path for simulation."
-        elif modelid:
-            # Create a BasicoModel object with the model ID
-            # model_object = BasicoModel(model_id=modelid)
-            model_object = BasicoModel(model_id=modelid)
-            # Save the model object in the Streamlit session state
-            st.session_state[self.st_session_key] = model_object
-        elif sbml_file_path:
-            # Create a BasicoModel object with the SBML file path
-            model_object = BasicoModel(sbml_file_path=sbml_file_path)
-            modelid = model_object.model_id
-            # Save the model object in the Streamlit session state
-            st.session_state[self.st_session_key] = model_object
-        # Add recurring events (if any) to the model
-        if recurring_data is not None:
-            for row in recurring_data.data:
-                tp, sn, sc = row.time, row.species_name, row.species_concentration
-                basico.add_event(f'{sn}_{tp}',
-                                 f'Time > {tp}',
-                                 [[sn, str(sc)]],
-                                 model=model_object.copasi_model)
-                # print (f'Added event {sn}_{tp} at time {tp} \
-                #        for species {sn} with concentration {sc}')
+        duration = 100.0
+        interval = 10
+        dic_species_data = None
+        if arg_data:
+            # Prepare the dictionary of species data
+            if arg_data.species_data is not None:
+                dic_species_data = dict(zip(arg_data.species_data.species_name,
+                                            arg_data.species_data.species_concentration))
+            # Add recurring events (if any) to the model
+            if arg_data.recurring_data is not None:
+                add_rec_events(model_object, arg_data.recurring_data)
+            # Set the duration and interval
+            if arg_data.time_data is not None:
+                duration = arg_data.time_data.duration
+                interval = arg_data.time_data.interval
+
         # Simulate the model
         df = model_object.simulate(
             parameters=dic_species_data,
-            duration=time_data.duration if time_data is not None else 100.0,
-            interval=time_data.interval if time_data is not None else 10)
-        # Convert the DataFrame to long format for plotting
-        # and ignore the index column
-        df = df.melt(id_vars='Time',
-                    var_name='Species',
-                    value_name='Concentration')
-        # Plot the simulation results using Plotly
-        # fig = px.line(df,
-        #                 x='Time',
-        #                 y='Concentration',
-        #                 color='Species',
-        #                 title=f"Concentration of Species over Time in the model {modelid}",
-        #                 height=600,
-        #                 width=800
-        # )
-        # Display the plot in Streamlit
-        # st.plotly_chart(fig, use_container_width = False)
-        # if modelid is None:
-        #     modelid = "internal"
-        # return f"Simulation results for the model {modelid}."
-        return "Simulation results for the model."
-
-    def get_metadata(self):
-        """
-        Get metadata for the tool.
+            duration=duration,
+            interval=interval
+            )
 
-        Returns:
-            dict: The metadata for the tool.
-        """
-        return {
-            "name": self.name,
-            "description": self.description
-        }
+        # Prepare the dictionary of updated state for the model
+        dic_updated_state_for_model = {}
+        for key, value in {
+                        "model_id": [sys_bio_model.biomodel_id],
+                        "sbml_file_path": [sbml_file_path],
+                        }.items():
+            if value:
+                dic_updated_state_for_model[key] = value
+
+        # Return the updated state of the tool
+        return Command(
+                update=dic_updated_state_for_model|{
+                # update the state keys
+                "dic_simulated_data": df.to_dict(),
+                # update the message history
+                "messages": [
+                    ToolMessage(
+                        content="Simulation results are ready.",
+                        tool_call_id=tool_call_id
+                        )
+                    ],
+                }
+            )

{aiagents4pharma-1.6.2.dist-info → aiagents4pharma-1.7.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: aiagents4pharma
-Version: 1.6.2
+Version: 1.7.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
@@ -13,6 +13,7 @@ Requires-Dist: coverage==7.6.4
 Requires-Dist: einops==0.8.0
 Requires-Dist: gdown==5.2.0
 Requires-Dist: huggingface_hub==0.26.5
+Requires-Dist: hydra-core==1.3.2
 Requires-Dist: joblib==1.4.2
 Requires-Dist: langchain==0.3.7
 Requires-Dist: langchain-community==0.3.5
@@ -43,7 +44,10 @@ Requires-Dist: mkdocs-include-markdown-plugin==7.1.2
 Requires-Dist: mkdocstrings==0.27.0
 Requires-Dist: streamlit-feedback
 
-[![TESTS](https://github.com/VirtualPatientEngine/AIAgents4Pharma/actions/workflows/tests.yml/badge.svg?branch=feat%2Finitial-setup)](https://github.com/VirtualPatientEngine/AIAgents4Pharma/actions/workflows/tests.yml)
+[![Talk2BioModels](https://github.com/VirtualPatientEngine/AIAgents4Pharma/actions/workflows/tests_talk2biomodels.yml/badge.svg)](https://github.com/VirtualPatientEngine/AIAgents4Pharma/actions/workflows/tests_talk2biomodels.yml)
+[![Talk2Cells](https://github.com/VirtualPatientEngine/AIAgents4Pharma/actions/workflows/tests_talk2cells.yml/badge.svg)](https://github.com/VirtualPatientEngine/AIAgents4Pharma/actions/workflows/tests_talk2cells.yml)
+[![Talk2KnowledgeGraphs](https://github.com/VirtualPatientEngine/AIAgents4Pharma/actions/workflows/tests_talk2knowledgegraphs.yml/badge.svg)](https://github.com/VirtualPatientEngine/AIAgents4Pharma/actions/workflows/tests_talk2knowledgegraphs.yml)
+[![Talk2Competitors](https://github.com/VirtualPatientEngine/AIAgents4Pharma/actions/workflows/tests_talk2competitors.yml/badge.svg)](https://github.com/VirtualPatientEngine/AIAgents4Pharma/actions/workflows/tests_talk2competitors.yml)
 
 <h1 align="center" style="border-bottom: none;">🤖 AIAgents4Pharma</h1>
 

{aiagents4pharma-1.6.2.dist-info → aiagents4pharma-1.7.0.dist-info}/RECORD

@@ -1,15 +1,15 @@
 aiagents4pharma/__init__.py,sha256=ds5Ft1k2ww2m7N-yv5ZyymBw0LBuHVjwC9TuekQBL_c,151
 aiagents4pharma/talk2biomodels/__init__.py,sha256=MueXwbnuiQyiju7mW6NepFUiZJdodMzmUK3TkQT7iPk,99
 aiagents4pharma/talk2biomodels/models/__init__.py,sha256=5fTHHm3PVloYPNKXbgNlcPgv3-u28ZquxGydFYDfhJA,122
-aiagents4pharma/talk2biomodels/models/basico_model.py,sha256=UzTj6EUS7GiaNJogRUY5LkEYv-mUw2kO10v1NW89nPw,4597
-aiagents4pharma/talk2biomodels/models/sys_bio_model.py,sha256=xN-ZXCpIxNkEXuDIvi_AW6LpCyPqXReGyhLPyJIXNqs,1980
-aiagents4pharma/talk2biomodels/tools/__init__.py,sha256=qO3MYCJmXpoUlZYtSW3VxTXdt-yUNHyH-Ua578pdyhg,280
-aiagents4pharma/talk2biomodels/tools/ask_question.py,sha256=o9ae4s3wsDFr_pGBU1cSxKhJ7E2yjybIzG1Y4z6957Y,4534
-aiagents4pharma/talk2biomodels/tools/custom_plotter.py,sha256=CdgJjlHAkdyjnwPD6nHARsJXnx_CE0MWg5VOz4oBjY0,2910
-aiagents4pharma/talk2biomodels/tools/fetch_parameters.py,sha256=WdLGPdJi4DwGwYMoReByGE9O1Msv68jkVd02F8L2liM,2864
-aiagents4pharma/talk2biomodels/tools/model_description.py,sha256=lcVKVvh50wJ4BmB7xMnTZOtWjCmQUnkh6TQJsX-IjGw,5338
-aiagents4pharma/talk2biomodels/tools/search_models.py,sha256=cqsK_ApjrAyjEiXWsXTebDpuvEnA5nb6WYiUGayRkW4,3034
-aiagents4pharma/talk2biomodels/tools/simulate_model.py,sha256=MxlAy62SuonBbEbKmoUz0HcdfTWvk-x9WMSo17dBU9U,7552
+aiagents4pharma/talk2biomodels/models/basico_model.py,sha256=js7ORLwbJPaIsko5oRToMMCh4l8LsN292OIvFzTfvRg,4946
+aiagents4pharma/talk2biomodels/models/sys_bio_model.py,sha256=ylpPba2SA8kl68q3k1kJbiUdRYplPHykyslTQLDZ19I,1995
+aiagents4pharma/talk2biomodels/tools/__init__.py,sha256=tkNUpUtZOe3hwbKQgp97e4gJ3p2d38G8WFHNO9A83uM,209
+aiagents4pharma/talk2biomodels/tools/ask_question.py,sha256=UEdT46DIFZHlAOF4cNX4_s7VjHvbbiGpNmEY2-XW2iA,2655
+aiagents4pharma/talk2biomodels/tools/custom_plotter.py,sha256=ESsdV_sz3wdynK9EbqZYhoY9r5zLto3NTZmUYvqS_TU,3282
+aiagents4pharma/talk2biomodels/tools/get_modelinfo.py,sha256=czxjRa9jvjTow-POGU5wSV8_lwfknAezBnzCFA0gQ8E,5189
+aiagents4pharma/talk2biomodels/tools/load_biomodel.py,sha256=QQOBCrDoEEWdSVCIYyBXL2WLSgEs3yB_fDpwALnsl-U,707
+aiagents4pharma/talk2biomodels/tools/search_models.py,sha256=GzF313UgawtrA0fvYEh_AX2HKO9eMV77YH-R__Gw3iY,2630
+aiagents4pharma/talk2biomodels/tools/simulate_model.py,sha256=Ax9nuHyINMIlqETujfYxqnzUsgLE-TUFV0EY5Qr7rPk,6249
 aiagents4pharma/talk2cells/__init__.py,sha256=zmOP5RAhabgKIQP-W4P4qKME2tG3fhAXM3MeO5_H8kE,120
 aiagents4pharma/talk2cells/agents/__init__.py,sha256=38nK2a_lEFRjO3qD6Fo9a3983ZCYat6hmJKWY61y2Mo,128
 aiagents4pharma/talk2cells/agents/scp_agent.py,sha256=gDMfhUNWHa_XWOqm1Ql6yLAdI_7bnIk5sRYn43H2sYk,3090
@@ -28,8 +28,8 @@ aiagents4pharma/talk2knowledgegraphs/utils/embeddings/__init__.py,sha256=xRb0x7S
 aiagents4pharma/talk2knowledgegraphs/utils/embeddings/embeddings.py,sha256=1nGznrAj-xT0xuSMBGz2dOujJ7M_IwSR84njxtxsy9A,2523
 aiagents4pharma/talk2knowledgegraphs/utils/embeddings/huggingface.py,sha256=2vi_elf6EgzfagFAO5QnL3a_aXZyN7B1EBziu44MTfM,3806
 aiagents4pharma/talk2knowledgegraphs/utils/embeddings/sentence_transformer.py,sha256=36iKlisOpMtGR5xfTAlSHXWvPqVC_Jbezod8kbBBMVg,2136
-aiagents4pharma-1.6.2.dist-info/LICENSE,sha256=IcIbyB1Hyk5ZDah03VNQvJkbNk2hkBCDqQ8qtnCvB4Q,1077
-aiagents4pharma-1.6.2.dist-info/METADATA,sha256=Lc-YDFCpxGDo0Y5kudger5uBuvmGP9l6edO6mtLM1BU,7242
-aiagents4pharma-1.6.2.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-aiagents4pharma-1.6.2.dist-info/top_level.txt,sha256=-AH8rMmrSnJtq7HaAObS78UU-cTCwvX660dSxeM7a0A,16
-aiagents4pharma-1.6.2.dist-info/RECORD,,
+aiagents4pharma-1.7.0.dist-info/LICENSE,sha256=IcIbyB1Hyk5ZDah03VNQvJkbNk2hkBCDqQ8qtnCvB4Q,1077
+aiagents4pharma-1.7.0.dist-info/METADATA,sha256=Ppwb-9bU-tkQ18AjrX6xmySzOrmcXIIszAL6j-ZpfCw,7988
+aiagents4pharma-1.7.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+aiagents4pharma-1.7.0.dist-info/top_level.txt,sha256=-AH8rMmrSnJtq7HaAObS78UU-cTCwvX660dSxeM7a0A,16
+aiagents4pharma-1.7.0.dist-info/RECORD,,

aiagents4pharma/talk2biomodels/tools/fetch_parameters.py

@@ -1,84 +0,0 @@
-#!/usr/bin/env python3
-
-"""
-Tool for fetching species and parameters from the model.
-"""
-
-from urllib.error import URLError
-from time import sleep
-from typing import Type
-import basico
-from pydantic import BaseModel, Field
-from langchain_core.tools import BaseTool
-import streamlit as st
-
-class FetchParametersInput(BaseModel):
-    """
-    Input schema for the ResetModel tool.
-    """
-    fetch_species: bool = Field(description="Fetch species from the model.")
-    fetch_parameters: bool = Field(description="Fetch parameters from the model.")
-
-# Note: It's important that every field has type hints. BaseTool is a
-# Pydantic class and not having type hints can lead to unexpected behavior.
-class FetchParametersTool(BaseTool):
-    """
-    This tool fetches species and parameters from the model 
-    and returns them as a string in a dictionary.
-    """
-    name: str = "fetch_parameters"
-    description: str = "A tool for fetching species and parameters from the model."
-    args_schema: Type[BaseModel] = FetchParametersInput
-    st_session_key: str = None
-
-    def _run(self,
-             fetch_species: bool,
-             fetch_parameters: bool
-             ) -> str:
-        """
-        Run the tool.
-
-        Args:
-            fetch_species (bool): Fetch species from the model.
-            fetch_parameters (bool): Fetch parameters from the model.
-
-        Returns:
-            dict: The species and parameters from the model.
-        """
-        model_obj = st.session_state[self.st_session_key]
-        # Extract species from the model
-        species = []
-        if fetch_species:
-            df_species = self.get_species_and_parameters(model_obj, fetch_species=True)
-            species = df_species.index.tolist()
-            species = ','.join(species)
-
-        # Extract parameters from the model
-        parameters = []
-        if fetch_parameters:
-            df_parameters = self.get_species_and_parameters(model_obj, fetch_species=False)
-            parameters = df_parameters.index.tolist()
-            parameters = ','.join(parameters)
-        return {'Species': species, 'Parameters': parameters}
-
-    def get_species_and_parameters(self,
-                                   model_obj,
-                                   fetch_species: bool):
-        """
-        Get the species from the model.
-        """
-        attempts = 0
-        max_retries = 3
-        while attempts < max_retries:
-            try:
-                if fetch_species:
-                    df = basico.model_info.get_species(model=model_obj.copasi_model)
-                else:
-                    df = basico.model_info.get_parameters(model=model_obj.copasi_model)
-                break
-            except URLError as e:
-                attempts += 1
-                sleep(10)
-                if attempts >= max_retries:
-                    raise e
-        return df

aiagents4pharma/talk2biomodels/tools/model_description.py

@@ -1,135 +0,0 @@
-#!/usr/bin/env python3
-
-"""
-Tool for asking a question about the model description.
-"""
-
-from typing import Type, Optional
-from dataclasses import dataclass
-from pydantic import BaseModel, Field, model_validator
-import streamlit as st
-from langchain_core.tools import BaseTool
-from langchain_core.output_parsers import StrOutputParser
-from langchain_core.callbacks import CallbackManagerForToolRun
-from langchain_core.prompts import ChatPromptTemplate
-from langchain_openai import ChatOpenAI
-from ..models.basico_model import BasicoModel
-
-@dataclass
-class ModelData:
-    """
-    Dataclass for storing the model data.
-    """
-    model_id: Optional[int] = None
-    sbml_file_path: Optional[str] = None
-    model_object: Optional[BasicoModel] = None
-
-    # Check if model_object is an instance of BasicoModel
-    # otherwise make it None. This is important because
-    # sometimes the LLM may invoke the tool with an
-    # inappropriate model_object.
-    @model_validator(mode="before")
-    @classmethod
-    def check_model_object(cls, data):
-        """
-        Check if model_object is an instance of BasicoModel.
-        """
-        if 'model_object' in data:
-            if not isinstance(data['model_object'], BasicoModel):
-                data['model_object'] = None
-        return data
-
-class ModelDescriptionInput(BaseModel):
-    """
-    Input schema for the ModelDescription tool.
-    """
-    question: str = Field(description="question about the model description")
-    sys_bio_model: ModelData = Field(description="model data", default=None)
-
-# Note: It's important that every field has type hints. BaseTool is a
-# Pydantic class and not having type hints can lead to unexpected behavior.
-class ModelDescriptionTool(BaseTool):
-    """
-    Tool for returning the description of the specified BioModel.
-    """
-    name: str = "model_description"
-    description: str = '''A tool to ask about the description of the model.'''
-    args_schema: Type[BaseModel] = ModelDescriptionInput
-    return_direct: bool = True
-    st_session_key: str = None
-
-    def _run(self,
-             question: str,
-             sys_bio_model: ModelData = ModelData(),
-             run_manager: Optional[CallbackManagerForToolRun] = None) -> str:
-        """
-        Run the tool.
-
-        Args:
-            question (str): The question to ask about the model description.
-            run_manager (Optional[CallbackManagerForToolRun]): The CallbackManagerForToolRun object.
-
-        Returns:
-            str: The answer to the question.
-        """
-        st_session_key = self.st_session_key
-        # Check if sys_bio_model is provided in the input schema
-        if sys_bio_model.model_id or sys_bio_model.sbml_file_path \
-            or sys_bio_model.model_object not in [None, "", {}]:
-            if sys_bio_model.model_id:
-                model_object = BasicoModel(model_id=sys_bio_model.model_id)
-            elif sys_bio_model.sbml_file_path:
-                model_object = BasicoModel(sbml_file_path=sys_bio_model.sbml_file_path)
-            else:
-                print (sys_bio_model.model_object, 'model_object')
-                model_object = sys_bio_model.model_object
-            if st_session_key:
-                st.session_state[st_session_key] = model_object
-        # Check if sys_bio_model is provided in the Streamlit session state
-        elif st_session_key:
-            if st_session_key not in st.session_state:
-                return f"Session key {st_session_key} " \
-                        "not found in Streamlit session state."
-            model_object = st.session_state[st_session_key]
-        else:
-            return "Please provide a valid model object or Streamlit "\
-                "session key that contains the model object."
-        # check if model_object is None
-        if model_object is None:
-            return "Please provide a BioModels ID or an SBML file path for the model."
-        description = model_object.description
-        if description in [None, ""]:
-            return "No description found for the model."
-        # Append the BioModel ID of the model to the description
-        description = f"{description} (BioModel ID: {model_object.model_id})"
-        llm = ChatOpenAI(model="gpt-3.5-turbo")
-        # Check if run_manager's metadata has the key 'prompt_content'
-        if run_manager and 'prompt' in run_manager.metadata:
-            prompt_content = run_manager.metadata['prompt']
-        else:
-            prompt_content = '''
-                            Given the description of a System biology model:
-                            {description},
-                            answer the user question:
-                            {question}.
-                            '''
-        prompt_template = ChatPromptTemplate.from_messages(
-            [("system", prompt_content),
-             ("user", "{description} {question}")]
-        )
-        parser = StrOutputParser()
-        chain = prompt_template | llm | parser
-        return chain.invoke({"description": description,
-                             "question": question})
-
-    def get_metadata(self):
-        """
-        Get metadata for the tool.
-
-        Returns:
-            dict: The metadata for the tool.
-        """
-        return {
-            "name": self.name,
-            "description": self.description
-        }