aiagents4pharma 1.0.0__py3-none-any.whl

aiagents4pharma/__init__.py

@@ -0,0 +1,5 @@
+'''
+This file is used to import the talk2biomodels module.
+'''
+
+from . import talk2biomodels

aiagents4pharma/talk2biomodels/__init__.py

@@ -0,0 +1,5 @@
+'''
+This file is used to import the models and tools.
+'''
+from . import models
+from . import tools

aiagents4pharma/talk2biomodels/models/__init__.py

@@ -0,0 +1,5 @@
+'''
+This file is used to import all the models in the package.
+'''
+from . import basico_model
+from . import sys_bio_model

aiagents4pharma/talk2biomodels/models/basico_model.py

@@ -0,0 +1,90 @@
+#!/usr/bin/env python3
+
+"""
+BasicoModel class for loading and simulating SBML models
+using the basico package.
+"""
+
+from typing import Optional, Dict, Union
+from pydantic import Field, model_validator
+import pandas as pd
+import basico
+from .sys_bio_model import SysBioModel
+
+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.
+    """
+    model_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")
+    description: Optional[str] = Field("", description="Description of the model")
+
+    # Additional attribute not included in the schema
+    copasi_model: Optional[object] = None  # Holds the loaded Copasi model
+
+    @model_validator(mode="after")
+    def check_model_id_or_sbml_file_path(self):
+        """
+        Validate that either model_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:
+            self.copasi_model = basico.load_biomodel(self.model_id)
+            self.description = basico.biomodels.get_model_info(self.model_id)["description"]
+        elif self.sbml_file_path:
+            self.copasi_model = basico.load_model(self.sbml_file_path)
+        return self
+
+    def simulate(self,
+                 parameters: Optional[Dict[str, Union[float, int]]] = None,
+                 duration: Union[int, float] = 10,
+                 interval: int = 10
+                 ) -> pd.DataFrame:
+        """
+        Simulate the COPASI model over a specified range of time points.
+        
+        Args:
+            parameters: Dictionary of model parameters to update before simulation.
+            duration: Duration of the simulation in time units.
+            interval: Interval between time points in the simulation.
+        
+        Returns:
+            Pandas DataFrame with time-course simulation results.
+        """
+
+        # Update parameters in the model
+        if parameters:
+            for param_name, param_value in parameters.items():
+                # check if the param_name is not None
+                if param_name is None:
+                    continue
+                basico.model_info.set_species(name=param_name,
+                                            exact=True,
+                                            initial_concentration=param_value,
+                                            model=self.copasi_model)
+
+        # Run the simulation and return results
+        df_result = basico.run_time_course(model=self.copasi_model,
+                                        intervals=interval,
+                                        duration=duration)
+        df_result.columns = df_result.columns.str.replace('{', '[', regex=False).\
+                    str.replace('}', ']', regex=False)
+        df_result.reset_index(inplace=True)
+        self.simulation_results = df_result
+        return df_result.copy()
+
+    def get_model_metadata(self) -> Dict[str, Union[str, int]]:
+        """
+        Retrieve metadata specific to the COPASI model.
+        
+        Returns:
+            Dictionary of model metadata.
+        """
+        return {
+            "Model Type": "SBML Model (COPASI)",
+            "Parameter Count": len(basico.get_parameters())
+        }

aiagents4pharma/talk2biomodels/models/sys_bio_model.py

@@ -0,0 +1,54 @@
+'''
+An abstract base class for BioModels in the BioModels repository.
+'''
+
+from abc import ABC, abstractmethod
+from typing import List, Dict, Union, Optional
+from pydantic import BaseModel, Field, model_validator
+
+class SysBioModel(ABC, BaseModel):
+    """
+    Abstract base class for BioModels in the BioModels repository.
+    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")
+    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):
+        """
+        Validate that either model_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.")
+        return self
+
+    @abstractmethod
+    def get_model_metadata(self) -> Dict[str, Union[str, int]]:
+        """
+        Abstract method to retrieve metadata of the model.
+        This method should return a dictionary containing model metadata.
+
+        Returns:
+            dict: Dictionary with model metadata
+        """
+
+    @abstractmethod
+    def simulate(self,
+                 parameters: Dict[str, Union[float, int]],
+                 duration: Union[int, float]) -> List[float]:
+        """
+        Abstract method to run a simulation of the model.
+        This method should be implemented to simulate model 
+        behavior based on the provided parameters.
+
+        Args:
+            parameters: Dictionary of parameter values.
+            duration: Duration of the simulation.
+
+        Returns:
+            list: List of simulation results.
+        """

aiagents4pharma/talk2biomodels/tools/__init__.py

@@ -0,0 +1,7 @@
+'''
+This file is used to import all the modules in the package.
+'''
+from . import simulate_model
+from . import model_description
+from . import ask_question
+from . import plot_figure

aiagents4pharma/talk2biomodels/tools/ask_question.py

@@ -0,0 +1,136 @@
+#!/usr/bin/env python3
+
+"""
+Tool for asking a question about the simulation results.
+"""
+
+from typing import Type, Optional
+from dataclasses import dataclass
+import streamlit as st
+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
+
+@dataclass
+class ModelData:
+    """
+    Dataclass for storing the model data.
+    """
+    modelid: Optional[int] = None
+    sbml_file_path: Optional[str] = None
+    model_object: Optional[BasicoModel] = None
+
+class AskQuestionInput(BaseModel):
+    """
+    Input schema for the AskQuestion tool.
+    """
+    question: str = Field(description="question about the simulation results")
+    sys_bio_model: ModelData = Field(description="model data", default=None)
+    st_session_key: str = Field(description="Streamlit session key", 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 AskQuestionTool(BaseTool):
+    """
+    Tool for calculating the product of two numbers.
+    """
+    name: str = "ask_question"
+    description: str = "A tool to ask question about the simulation results."
+    args_schema: Type[BaseModel] = AskQuestionInput
+    return_direct: bool = True
+
+    def _run(self,
+             question: str,
+             sys_bio_model: ModelData = ModelData(),
+             st_session_key: str = None,
+             run_manager: Optional[CallbackManagerForToolRun] = None) -> str:
+        """
+        Run the tool.
+
+        Args:
+            question (str): The question to ask about the simulation results.
+            st_session_key (str): The Streamlit session key.
+            run_manager (Optional[CallbackManagerForToolRun]): The CallbackManagerForToolRun object.
+
+        Returns:
+            str: The answer to the question.
+        """
+        # 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'
+        prompt_content = None
+        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)
+        llm_result = df_agent.invoke(question)
+        return llm_result["output"]
+
+    def call_run(self,
+            question: str,
+            sys_bio_model: ModelData = ModelData(),
+            st_session_key: str = None,
+            run_manager: Optional[CallbackManagerForToolRun] = None) -> str:
+        """
+        Run the tool.
+
+        Args:
+            question (str): The question to ask about the simulation results.
+            sys_bio_model (ModelData): The model data.
+            st_session_key (str): The Streamlit session key.
+            run_manager (Optional[CallbackManagerForToolRun]): The CallbackManagerForToolRun object.
+
+        Returns:
+            str: The answer to the question.
+        """
+        return self._run(question=question,
+                         sys_bio_model=sys_bio_model,
+                         st_session_key=st_session_key,
+                         run_manager=run_manager)
+
+    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/model_description.py

@@ -0,0 +1,161 @@
+#!/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.
+    """
+    modelid: 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)
+    st_session_key: str = Field(description="Streamlit session key", 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
+
+    def _run(self,
+             question: str,
+             sys_bio_model: ModelData = ModelData(),
+             st_session_key: str = None,
+             run_manager: Optional[CallbackManagerForToolRun] = None) -> str:
+        """
+        Run the tool.
+
+        Args:
+            question (str): The question to ask about the model description.
+            st_session_key (str): The Streamlit session key.
+            run_manager (Optional[CallbackManagerForToolRun]): The CallbackManagerForToolRun object.
+
+        Returns:
+            str: The answer to the question.
+        """
+        # Check if sys_bio_model is provided in the input schema
+        if sys_bio_model.modelid or sys_bio_model.sbml_file_path \
+            or sys_bio_model.model_object not in [None, "", {}]:
+            if sys_bio_model.modelid:
+                model_object = BasicoModel(model_id=sys_bio_model.modelid)
+            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 call_run(self,
+            question: str,
+            sys_bio_model: ModelData = ModelData(),
+            st_session_key: str = None,
+            run_manager: Optional[CallbackManagerForToolRun] = None) -> str:
+        """
+        Run the tool.
+
+        Args:
+            question (str): The question to ask about the model description.
+            sys_bio_model (ModelData): The model data.
+            st_session_key (str): The Streamlit session key.
+            run_manager (Optional[CallbackManagerForToolRun]): The CallbackManagerForToolRun object.
+        
+        Returns:
+            str: The answer to the question
+        """
+        return self._run(question=question,
+                         sys_bio_model=sys_bio_model,
+                         st_session_key=st_session_key,
+                         run_manager=run_manager)
+
+    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/plot_figure.py

@@ -0,0 +1,135 @@
+#!/usr/bin/env python3
+
+"""
+Tool for plotting a figure.
+"""
+
+from typing import Type, Optional
+from dataclasses import dataclass
+import matplotlib.pyplot as plt
+from pydantic import BaseModel, Field
+import streamlit as st
+from langchain_openai import ChatOpenAI
+from langchain_core.tools import BaseTool
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.output_parsers.openai_tools import JsonOutputKeyToolsParser
+from langchain_experimental.tools import PythonAstREPLTool
+from ..models.basico_model import BasicoModel
+
+@dataclass
+class ModelData:
+    """
+    Dataclass for storing the model data.
+    """
+    modelid: Optional[int] = None
+    sbml_file_path: Optional[str] = None
+    model_object: Optional[BasicoModel] = None
+
+class PlotImageInput(BaseModel):
+    """
+    Input schema for the PlotImage tool.
+    """
+    question: str = Field(description="Description of the plot")
+    sys_bio_model: ModelData = Field(description="model data", default=None)
+    st_session_key: str = Field(description="Streamlit session key", 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 PlotImageTool(BaseTool):
+    """
+    Tool for plotting a figure.
+    """
+    name: str = "plot_figure"
+    description: str = "A tool to plot or visualize the simulation results."
+    args_schema: Type[BaseModel] = PlotImageInput
+
+    def _run(self,
+             question: str,
+             sys_bio_model: ModelData = ModelData(),
+             st_session_key: str = None) -> str:
+        """
+        Run the tool.
+
+        Args:
+            question (str): The question to ask about the model description.
+            st_session_key (str): The Streamlit session key.
+
+        Returns:
+            str: The answer to the question
+        """
+        # Check if sys_bio_model is provided
+        if sys_bio_model.modelid or sys_bio_model.sbml_file_path or sys_bio_model.model_object:
+            if sys_bio_model.modelid:
+                model_object = BasicoModel(model_id=sys_bio_model.modelid)
+            elif sys_bio_model.sbml_file_path:
+                model_object = BasicoModel(sbml_file_path=sys_bio_model.sbml_file_path)
+            else:
+                model_object = sys_bio_model.model_object
+            if st_session_key:
+                st.session_state[st_session_key] = model_object
+        else:
+            # If the model_object is not provided,
+            # 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."
+        if model_object is None:
+            return "Please run the simulation first before plotting the figure."
+        if model_object.simulation_results is None:
+            model_object.simulate()
+        df = model_object.simulation_results
+        tool = PythonAstREPLTool(locals={"df": df})
+        llm = ChatOpenAI(model="gpt-3.5-turbo")
+        llm_with_tools = llm.bind_tools([tool], tool_choice=tool.name)
+        system = f"""
+                    You have access to a pandas dataframe `df`.
+                    Here is the output of `df.head().to_markdown()`:
+                    {df.head().to_markdown()}
+                    Given a user question, write the Python code to
+                    plot a figure of the answer using matplolib.
+                    Return ONLY the valid Python code and nothing else.
+                    The firgure size should be equal or smaller than (2, 2).
+                    Show the grid and legend. The font size of the legend should be 6.
+                    Also write a suitable title for the figure. The font size of the title should be 8.
+                    The font size of the x-axis and y-axis labels should be 8.
+                    The font size of the x-axis and y-axis ticks should be 6.
+                    Make sure that the x-axis has at least 10 tick marks.
+                    Use color-blind friendly colors. The figure must be of high quality.
+                    Don't assume you have access to any libraries other
+                    than built-in Python ones, pandas, streamlit and matplotlib.
+                    """
+        prompt = ChatPromptTemplate.from_messages([("system", system), ("human", "{question}")])
+        parser = JsonOutputKeyToolsParser(key_name=tool.name, first_tool_only=True)
+        code_chain = prompt | llm_with_tools | parser
+        response = code_chain.invoke({"question": question})
+        exec(response['query'], globals(), {"df": df, "plt": plt})
+        # load for plotly
+        fig = plt.gcf()
+        if st_session_key:
+            st.pyplot(fig, use_container_width=False)
+            st.dataframe(df)
+        return "Figure plotted successfully"
+
+    def call_run(self,
+            question: str,
+            sys_bio_model: ModelData = ModelData(),
+            st_session_key: str = None) -> str:
+        """
+        Run the tool.
+        """
+        return self._run(question=question,
+                         sys_bio_model=sys_bio_model,
+                         st_session_key=st_session_key)
+
+    def get_metadata(self):
+        """
+        Get metadata for the tool.
+        """
+        return {
+            "name": self.name,
+            "description": self.description
+        }

aiagents4pharma/talk2biomodels/tools/simulate_model.py

@@ -0,0 +1,179 @@
+#!/usr/bin/env python3
+
+"""
+Tool for simulating a model.
+"""
+
+from typing import Type, Union, List, Optional
+from dataclasses import dataclass
+from pydantic import BaseModel, Field
+from langchain_core.tools import BaseTool
+import streamlit as st
+import plotly.express as px
+from ..models.basico_model import BasicoModel
+
+@dataclass
+class ModelData:
+    """
+    Dataclass for storing the model data.
+    """
+    modelid: Optional[int] = None
+    sbml_file_path: Optional[str] = None
+
+@dataclass
+class TimeData:
+    """
+    Dataclass for storing the time data.
+    """
+    duration: Union[int, float] = 100
+    interval: Union[int, float] = 10
+
+@dataclass
+class SpeciesData:
+    """
+    Dataclass for storing the species data.
+    """
+    species_name: List[str] = None
+    species_concentration: List[Union[int, float]] = None
+
+class SimulateModelInput(BaseModel):
+    """
+    Input schema for the SimulateModel tool.
+    """
+    st_session_key: str = Field(description="Streamlit session key", default=None)
+    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)
+
+# 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 SimulateModelTool(BaseTool):
+    """
+    Tool for simulating a model.
+    """
+    name: str = "simulate_model"
+    description: str = "A tool for simulating a model."
+    args_schema: Type[BaseModel] = SimulateModelInput
+
+    def _run(self,
+                model_data: ModelData = None,
+                time_data: TimeData = None,
+                species_data: SpeciesData = None,
+                st_session_key: str = None):
+        """
+        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.
+            st_session_key (str): The Streamlit session key
+
+        Returns:
+            str: The result of the simulation.
+        """
+        # 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
+        # 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))
+        # 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 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."
+            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 st_session_key:
+                model_object = st.session_state[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[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[st_session_key] = model_object
+        # Simulate the model
+        df = model_object.simulate(parameters=dic_species_data,
+                                    duration=duration,
+                                    interval=interval)
+        # 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"
+        content = f"Simulation results for the model {modelid}."
+        return content
+
+    def call_run(self,
+                model_data: ModelData = None,
+                time_data: TimeData = None,
+                species_data: SpeciesData = None,
+                st_session_key: str = None) -> str:
+        """
+        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.
+            st_session_key (str): The Streamlit session key
+
+        Returns:
+            str: The result of the simulation.
+        """
+        return self._run(model_data=model_data,
+                        time_data=time_data,
+                        species_data=species_data,
+                        st_session_key=st_session_key)
+
+    def get_metadata(self):
+        """
+        Get metadata for the tool.
+
+        Returns:
+            dict: The metadata for the tool.
+        """
+        return {
+            "name": self.name,
+            "description": self.description,
+            "return_direct": self.return_direct,
+        }

aiagents4pharma-1.0.0.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 VirtualPatientEngine
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

aiagents4pharma-1.0.0.dist-info/METADATA

@@ -0,0 +1,135 @@
+Metadata-Version: 2.1
+Name: aiagents4pharma
+Version: 1.0.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
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: copasi-basico==0.78
+Requires-Dist: coverage==7.6.4
+Requires-Dist: langchain==0.3.7
+Requires-Dist: langchain-community==0.3.5
+Requires-Dist: langchain-core==0.3.15
+Requires-Dist: langchain-experimental==0.3.3
+Requires-Dist: langchain-openai==0.2.5
+Requires-Dist: matplotlib==3.9.2
+Requires-Dist: openai==1.53.0
+Requires-Dist: pandas==2.2.3
+Requires-Dist: plotly==5.24.1
+Requires-Dist: pydantic==2.9.2
+Requires-Dist: pylint==3.3.1
+Requires-Dist: pytest==8.3.3
+Requires-Dist: streamlit==1.39.0
+Requires-Dist: tabulate==0.9.0
+Requires-Dist: tqdm==4.66.6
+
+[![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)
+
+<h1 align="center" style="border-bottom: none;">🤖 AIAgents4Pharma</h1>
+
+Welcome to **AIAgents4Pharma** – an open-source project by [Team VPE](https://github.com/VirtualPatientEngine) that brings together AI-driven tools to help researchers and pharma interact seamlessly with complex biological data.
+
+Our toolkit currently consists of three intelligent agents, each designed to simplify and enhance access to specialized data in biology:
+
+- **Talk2BioModels**: Engage directly with mathematical models in systems biology.
+- **Talk2Cells** *(Coming soon)*: Query and analyze sequencing data with ease.
+- **Talk2KnowledgeGraphs** *(Coming soon)*: Access and explore complex biological knowledge graphs for insightful data connections.
+
+---
+
+## Overview of Agents
+
+### 1. Talk2BioModels
+
+**Talk2BioModels** is an AI agent designed to facilitate interaction with mathematical models in systems biology. Systems biology models are critical in understanding complex biological mechanisms, but they’re often inaccessible to those without coding or mathematical expertise. Talk2BioModels simplifies this, enabling researchers to focus on analysis and interpretation rather than on programming. With Talk2BioModels, users can interact directly with these models through natural language. By simply asking questions or making requests, users can:
+
+- Forward simulation of both internal and open-source models (BioModels).
+- Adjust parameters within the model to simulate different conditions.
+- Query simulation results.
+
+### 2. Talk2Cells *(Coming soon)*
+
+**Talk2Cells** is being developed to provide direct access to and analysis of sequencing data, such as RNA-Seq or DNA-Seq, using natural language.
+
+### 3. Talk2KnowledgeGraphs *(Work in Progress)*
+
+**Talk2KnowledgeGraphs** is an agent designed to enable interaction with biological knowledge graphs (KGs). KGs integrate vast amounts of structured biological data into a format that highlights relationships between entities, such as proteins, genes, and diseases.
+
+## Getting Started
+
+### Prerequisites
+
+- **Python 3.10+**
+- **Git**
+- Required libraries specified in `requirements.txt`
+
+### Installation
+
+1. **Clone the repository:**
+   ```bash
+   git clone https://github.com/VirtualPatientEngine/AIAgents4Pharma
+   cd AIAgents4Pharma
+   ```
+
+2. **Install dependencies:**
+   ```bash
+   pip install -r requirements.txt
+   ```
+
+3. **Initialize OPENAI_API_KEY**
+   ```bash
+   export OPENAI_API_KEY = ....
+   ```
+
+4. **Launch the agent:**
+   To launch the Talk2BioModels agent, run:
+   ```bash
+   streamlit run app/frontend/streamlit_app.py
+   ```
+
+For detailed instructions on each agent, please refer to their respective folders.
+
+---
+
+## Usage
+
+**Talk2BioModels** currently provides an interactive console where you can enter natural language queries to simulate models, adjust parameters, and query the simulated results.
+
+More detailed usage examples, including sample data for Talk2Cells and Talk2KnowledgeGraphs, will be provided as development progresses.
+
+---
+
+## Contributing
+
+We welcome contributions to AIAgents4Pharma! Here’s how you can help:
+
+1. **Fork the repository**
+2. **Create a new branch** for your feature (`git checkout -b feat/feature-name`)
+3. **Commit your changes** (`git commit -m 'feat: Add new feature'`)
+4. **Push to the branch** (`git push origin feat/feature-name`)
+5. **Open a pull request**
+
+### Current Needs
+- **Beta testers** for Talk2BioModels.
+- **Developers** with experience in natural language processing, bioinformatics, or knowledge graphs for contributions to AIAgents4Pharma.
+
+Check out our [CONTRIBUTING.md](CONTRIBUTING.md) for more information.
+
+---
+
+## Roadmap
+
+### Completed
+- **Talk2BioModels**: Initial release with core capabilities for interacting with systems biology models.
+
+### Planned
+- **User Interface**: Interactive web UI for all agents.
+- **Talk2Cells**: Integration of sequencing data analysis tools.
+- **Talk2KnowledgeGraphs**: Interface for biological knowledge graph interaction.
+
+We’re excited to bring AIAgents4Pharma to the bioinformatics and pharmaceutical research community. Together, let’s make data-driven biological research more accessible and insightful. 
+
+**Get Started** with AIAgents4Pharma today and transform the way you interact with biological data.

aiagents4pharma-1.0.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+aiagents4pharma/__init__.py,sha256=OF-rmtiLauF4NIlzEvMrWhNiX-mo5NJ4vrUtQbcLwts,93
+aiagents4pharma/talk2biomodels/__init__.py,sha256=MueXwbnuiQyiju7mW6NepFUiZJdodMzmUK3TkQT7iPk,99
+aiagents4pharma/talk2biomodels/models/__init__.py,sha256=5fTHHm3PVloYPNKXbgNlcPgv3-u28ZquxGydFYDfhJA,122
+aiagents4pharma/talk2biomodels/models/basico_model.py,sha256=zJeLfqGJnQp9baJUsovgQV_WFsVTP2TVZmOG60GyeP8,3639
+aiagents4pharma/talk2biomodels/models/sys_bio_model.py,sha256=xN-ZXCpIxNkEXuDIvi_AW6LpCyPqXReGyhLPyJIXNqs,1980
+aiagents4pharma/talk2biomodels/tools/__init__.py,sha256=AM03pbYT3nOzI5jf_CJmSDaDwrI-IZ0Zq9hLA2tOXpw,182
+aiagents4pharma/talk2biomodels/tools/ask_question.py,sha256=WYEtNuy-wAuwMbP9W9l0qmcHmIuW1ZFMX7SvoYgkv0A,5530
+aiagents4pharma/talk2biomodels/tools/model_description.py,sha256=NawUK549IqlC36dUmJjIBI1QGeLpNV-JlBt7AiV2BDs,6295
+aiagents4pharma/talk2biomodels/tools/plot_figure.py,sha256=8QHH6gA7vI85e8RsWJSX8ZAH_WsuIBGLpYqyr4CllVQ,5648
+aiagents4pharma/talk2biomodels/tools/simulate_model.py,sha256=phUtNScCZQ281MvcU0N2NMkg4Lb8NmfXiMAVt3ON_UQ,6959
+aiagents4pharma-1.0.0.dist-info/LICENSE,sha256=IcIbyB1Hyk5ZDah03VNQvJkbNk2hkBCDqQ8qtnCvB4Q,1077
+aiagents4pharma-1.0.0.dist-info/METADATA,sha256=h0lOu1rCm0LNRLdvyFa7NG1OVz6ORrL1wWx8fA73kvA,5460
+aiagents4pharma-1.0.0.dist-info/WHEEL,sha256=a7TGlA-5DaHMRrarXjVbQagU3Man_dCnGIWMJr5kRWo,91
+aiagents4pharma-1.0.0.dist-info/top_level.txt,sha256=-AH8rMmrSnJtq7HaAObS78UU-cTCwvX660dSxeM7a0A,16
+aiagents4pharma-1.0.0.dist-info/RECORD,,

aiagents4pharma-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.4.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

aiagents4pharma-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+aiagents4pharma